vimniscient 0.2.0__tar.gz → 0.2.2__tar.gz

{vimniscient-0.2.0 → vimniscient-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vimniscient
-Version: 0.2.0
+Version: 0.2.2
 Summary: Get fluent in Vim in fifteen minutes a day, in your own Neovim.
 Project-URL: Homepage, https://vimniscient.com
 Project-URL: Source, https://github.com/dialectmaterial/Vimniscient
@@ -301,6 +301,8 @@ uv run python tests/check_lessons.py --lazyvim  # LazyVim lessons, in your own c
 uv run python tests/check_answers.py            # card answers written different ways
 uv run python tests/check_timing.py             # task times: old progress databases upgrade safely
 uv run python tests/check_generate.py           # generated texts: reproducible, and they solve in Neovim
+uv run python tests/check_diagnose.py           # strategy feedback: no reference solution sets it off
+uv run python tests/check_transfer.py           # Choose: every way solves it in Neovim, nothing graded
 uv run python tests/check_today.py              # the daily budget, SRS scheduling, card introductions, hardtime
 uv run python tests/check_app.py                # every screen, driven headless
 uv run python tests/live_lessons.py --all       # types every solution into the real runner (needs tmux)

{vimniscient-0.2.0 → vimniscient-0.2.2}/README.md

@@ -278,6 +278,8 @@ uv run python tests/check_lessons.py --lazyvim  # LazyVim lessons, in your own c
 uv run python tests/check_answers.py            # card answers written different ways
 uv run python tests/check_timing.py             # task times: old progress databases upgrade safely
 uv run python tests/check_generate.py           # generated texts: reproducible, and they solve in Neovim
+uv run python tests/check_diagnose.py           # strategy feedback: no reference solution sets it off
+uv run python tests/check_transfer.py           # Choose: every way solves it in Neovim, nothing graded
 uv run python tests/check_today.py              # the daily budget, SRS scheduling, card introductions, hardtime
 uv run python tests/check_app.py                # every screen, driven headless
 uv run python tests/live_lessons.py --all       # types every solution into the real runner (needs tmux)

{vimniscient-0.2.0 → vimniscient-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vimniscient"
-version = "0.2.0"
+version = "0.2.2"
 description = "Get fluent in Vim in fifteen minutes a day, in your own Neovim."
 readme = "README.md"
 license = "AGPL-3.0-or-later"

{vimniscient-0.2.0 → vimniscient-0.2.2}/src/vimniscient/answer.py

@@ -40,7 +40,7 @@ def _norm_token(match: re.Match) -> str:
 
 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)^(leader|space|spc)(\s*\+\s*|\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)
@@ -55,7 +55,7 @@ _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",
+    "SHIFT": "SHIFT", "PREFIX": "PREFIX", "LEADER": "PREFIX", "COPYMODE": "COPYMODE",
 }
 _KEY_ALIASES = {
     "ENTER": "RETURN", "CR": "RETURN", "ESC": "ESCAPE", "DEL": "DELETE", "INS": "INSERT",

{vimniscient-0.2.0 → vimniscient-0.2.2}/src/vimniscient/app.py

@@ -11,13 +11,14 @@ from dataclasses import replace
 
 from textual.app import App
 from textual.color import Color
+from textual.content import Content
 
-from vimniscient import drills, endless, reminders, today, vimgolf
+from vimniscient import drills, endless, reminders, today, transfer, 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.builtin_lessons import endless_lesson, placement_lesson, review_lesson, transfer_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
@@ -44,7 +45,7 @@ class VimniscientApp(App):
 
     #main { height: 1fr; }
     #left { width: 46; max-width: 45%; }
-    #plan { height: 8; }
+    #plan { height: 9; }
     #lesson-list { height: 1fr; }
     #right { width: 1fr; }
     #detail-pane { height: 1fr; }
@@ -74,7 +75,7 @@ class VimniscientApp(App):
     #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; }
+    #results-why, #results-advice { 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; }
@@ -121,7 +122,7 @@ class VimniscientApp(App):
     def start_lesson(
         self,
         lesson: Lesson,
-        on_results: Callable[[list[TaskResult]], str] | None = None,
+        on_results: Callable[[list[TaskResult]], str | Content] | None = None,
         done: Callable[[], None] = lambda: None,
     ) -> None:
         """Run a lesson in Neovim, then show the results; `done` runs when the user moves on.
@@ -188,6 +189,10 @@ class VimniscientApp(App):
         elif step_id == "vimgolf":
             if not progress.vimgolf_done_today():
                 return self.start_vimgolf
+        elif step_id == "transfer":
+            picks = transfer.pick(self.lessons, progress)
+            if picks:
+                return lambda done: self.start_transfer(picks, done)
         elif step_id == "endless":
             start = progress.endless_start(endless.RESTART_BELOW)
             if direct:
@@ -252,6 +257,19 @@ class VimniscientApp(App):
     def action_endless(self) -> None:
         self.run_step("endless", lambda: None)
 
+    def action_transfer(self) -> None:
+        self.run_step("transfer", lambda: None)
+
+    def start_transfer(self, picks: list[transfer.Challenge], done: Callable[[], None]) -> None:
+        def on_results(results: list[TaskResult]) -> Content:
+            self.progress.record_transfer(results)
+            by_goal = {c.task.goal: c for c in picks}
+            lines = [f"{r.task.goal}  {'  or  '.join(ways)}" for r in results
+                     if (ways := transfer.another_way(by_goal[r.task.goal], r.keys, r.status == "solved"))]
+            return Content("Another way\n" + "\n".join(lines)) if lines else Content("")
+
+        self.start_lesson(transfer_lesson([c.task for c in picks]), on_results, done)
+
     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()

{vimniscient-0.2.0 → vimniscient-0.2.2}/src/vimniscient/cards/lazyvim.yaml

@@ -12,7 +12,7 @@ cards:
   - {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: File explorer (neo-tree), answer: [<leader>e], note: 'e is explorer.'}
   - {prompt: Next buffer, answer: [<S-l>, ']b']}
   - {prompt: Previous buffer, answer: [<S-h>, '[b']}
   - {prompt: Delete the buffer, answer: [<leader>bd]}

{vimniscient-0.2.0 → vimniscient-0.2.2}/src/vimniscient/cards/shell.yaml

@@ -5,9 +5,9 @@ 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: Jump to the start of the line, answer: [<C-a>, <Home>], note: 'a is the start of the alphabet. The shell isn’t Vim: 0 and $ just type themselves.'}
+  - {prompt: Jump to the end of the line, answer: [<C-e>, <End>], note: 'e is end. The shell isn’t Vim: $ just types itself.'}
+  - {prompt: Delete the word before the cursor, answer: [<C-w>], note: 'w is word.'}
   - {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>]}

{vimniscient-0.2.0 → vimniscient-0.2.2}/src/vimniscient/cards/vim.yaml

@@ -7,8 +7,8 @@ case_sensitive: true
 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, id: 'vim:Delete a word and the space after it', prompt: 'Delete the whole word under the cursor, wherever in it the cursor is, and the space after it', answer: [daw], note: 'dw only deletes from the cursor on.'}
+  - {week: 1, day: 1, id: 'vim:Change a WORD (space to space, punctuation included)', prompt: 'Change the whole WORD under the cursor (space to space, punctuation included), keeping the space after it', 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"']}

{vimniscient-0.2.0 → vimniscient-0.2.2}/src/vimniscient/cards.py

@@ -77,7 +77,7 @@ def _static_decks() -> dict[str, Deck]:
             deck.cards.append(
                 Card(
                     deck=deck.id,
-                    id=f"{deck.id}:{c['prompt']}",
+                    id=c.get("id", f"{deck.id}:{c['prompt']}"),  # `id` keeps a reworded card's history
                     prompt=c["prompt"],
                     answers=[str(a) for a in c["answer"]],
                     style=data.get("style", "keys"),

vimniscient-0.2.2/src/vimniscient/diagnose.py

@@ -0,0 +1,113 @@
+"""What your own keys say about your strategy, on the results screen.
+
+A few rules, each one certain from the keys alone, so that a task with nothing
+clear to say says nothing. They only speak when you went over the reference,
+and never about text you typed in insert mode (tests/check_diagnose.py checks
+that no reference solution sets one off).
+"""
+
+import re
+
+from vimniscient.keys import split_keys
+
+MOTION_RUN = 4  # jjjj; Vjj in a reference is fine, and three presses aren't a habit
+X_RUN = 3
+MOTIONS = {"h", "j", "k", "l", "w", "b", "e"}
+OPERATORS = {"c", "d", "y", ">", "<", "="}
+TAKES_CHAR = {"f", "t", "F", "T", "r", "m", "'", "`", "@", '"'}
+INSERTS = {"i", "a", "A", "I", "o", "O", "s", "S", "C", "R"}
+_REPEAT = re.compile(r"((?:<[^<>\s]+>|.){3,}?)\1\1", re.S)
+
+
+def _skip_line(tokens: list[str], i: int) -> int:
+    while i < len(tokens) and tokens[i] != "<CR>":
+        i += 1
+    return i + 1
+
+
+def _skip_insert(tokens: list[str], i: int) -> int:
+    while i < len(tokens) and tokens[i] != "<Esc>":
+        i += 1
+    return i + 1
+
+
+def _skip_motion(tokens: list[str], i: int) -> int:
+    """Past what follows an operator: a count, then a motion or a text object."""
+    while i < len(tokens) and tokens[i].isdigit():
+        i += 1
+    if i >= len(tokens):
+        return i
+    key = tokens[i]
+    if key in ("/", "?"):
+        return _skip_line(tokens, i + 1)
+    return i + (2 if key in {"i", "a", "g", "f", "t", "F", "T", "'", "`"} else 1)
+
+
+def normal_keys(keys: str) -> list[list[str]]:
+    """The runs of keys pressed as commands: not typed text, search or `:` lines."""
+    tokens, runs, run = split_keys(keys), [], []
+    i, visual, recording = 0, False, False
+    while i < len(tokens):
+        key = tokens[i]
+        i += 1
+        if key in (":", "/", "?"):
+            i, visual = _skip_line(tokens, i), False
+        elif visual and key in {"c", "s", "I", "A"}:
+            i, visual = _skip_insert(tokens, i), False
+        elif visual and key in OPERATORS | {"x", "J", "U", "u", "<Esc>"}:
+            visual = False
+        elif key in OPERATORS:
+            if tokens[i:i + 1] == [key]:  # dd, cc, yy
+                i += 1
+            else:
+                i = _skip_motion(tokens, i)
+            if key == "c":
+                i = _skip_insert(tokens, i)
+        elif key == "g" and tokens[i:i + 1] and tokens[i] in {"U", "u", "~"}:
+            i = _skip_motion(tokens, i + 1)
+        elif key == "g":
+            i += 1
+        elif key in TAKES_CHAR:
+            i += 1
+        elif key == "q":
+            i += 0 if recording else 1
+            recording = not recording
+        elif key in INSERTS:
+            i = _skip_insert(tokens, i)
+        else:
+            visual = visual or key in {"v", "V", "<C-v>"}
+            run.append(key)
+            continue
+        if run:
+            runs.append(run)
+            run = []
+    return [*runs, run] if run else runs
+
+
+def _longest_run(runs: list[list[str]], wanted: set[str]) -> tuple[str, int]:
+    best, length = "", 0
+    for tokens in runs:
+        last, n = "", 0
+        for key in tokens:
+            n = n + 1 if key == last else 1
+            last = key
+            if key in wanted and n > length:
+                best, length = key, n
+    return best, length
+
+
+def diagnose(keys: str, count: int, ref: int) -> str:
+    """One thing worth saying about how `keys` went about it, or nothing."""
+    if count <= ref:
+        return ""
+    runs = normal_keys(keys)
+    motion, length = _longest_run(runs, MOTIONS)
+    if length >= MOTION_RUN:
+        better = "f, t, / or a count" if motion in "hl" else "a count"
+        return f"{motion} {length} times in a row: {better} gets there in one go."
+    if _longest_run(runs, {"x"})[1] >= X_RUN:
+        return "x over and over: a count, dw or diw takes it all at once."
+    repeat = _REPEAT.search(keys)
+    if repeat and not any("." in run for run in runs) and "<Esc>" in repeat.group(1):
+        return f"You typed {repeat.group(1)} three times: . repeats the last change."
+    return ""

{vimniscient-0.2.0 → vimniscient-0.2.2}/src/vimniscient/endless.py

@@ -45,7 +45,7 @@ def ladder(lessons: list[Lesson], start: int, length: int = RUNGS, seed: object
         lesson = mix[-1] if rng.random() < 0.5 else rng.choice(mix)
         task = rng.choice([t for t in lesson.tasks if t.item_id not in recent] or lesson.tasks)
         recent.append(task.item_id)
-        rungs.append((task, rng.randrange(task.versions)))
+        rungs.append((task, rng.randrange(task.choices)))
     return rungs
 
 

vimniscient-0.2.2/src/vimniscient/generate.py

@@ -0,0 +1,215 @@
+"""Practice texts made from a seed, for skills where any sentence will do.
+
+A lesson task can name a `generate` kind. Its Learn round keeps the authored
+text; Recall and reviews can get a generated one instead, so a skill gets
+practised on sentences you haven't seen. The same seed always gives the same
+task, so a run can be replayed and every kind can be checked in Neovim
+(tests/check_generate.py).
+
+The sentences stay mnemonic: they're the hooks from mnemonics.yaml, what keys
+stand for.
+
+Kinds:
+  ciw-typo    two letters of a word swapped; ciw and type it right
+  daw-double  a word doubled; daw deletes one copy and its space
+  ciW-dotted  a word written with dots between its letters; ciW rewrites it
+  ci-quote    a key's meaning, wrong, in double quotes; ci" fixes it
+  di-paren    the arguments of a call; di( empties it
+  da-paren    a call's arguments; da( takes the parentheses too
+  di-bracket  a list of keys; di[ empties it
+  dt-letter   filler before a word; dt and the word's first letter
+  D-rest      filler after a sentence; D deletes to the end of the line
+  J-split     a sentence over two lines; J joins them
+  ddp-swap    two lines the wrong way round; ddp swaps them
+  count-dw    a few filler words; a count on dw
+  count-dd    a few filler lines; a count on dd
+  count-x     stray x letters; a count on x
+"""
+
+import random
+import re
+from dataclasses import replace
+from functools import cache
+from importlib import resources
+
+import yaml
+
+from vimniscient.lessons import Task, load_lessons
+from vimniscient.mnemonics import _tables
+from vimniscient.mnemonics import hooks as key_hooks
+
+FILLER = ("um", "well", "like", "so")
+
+
+@cache
+def sentences() -> list[str]:
+    """The hooks of the keys week 1 teaches: nothing about keys you haven't met yet."""
+    known = {hook for lesson in load_lessons() if lesson.week == 1 for key in lesson.keys for hook in key_hooks(key)}
+    hooks = [hook for hook in dict.fromkeys(hook for table in _tables()[:2] for hook in table.values()) if hook in known]
+    # as written: a capital would change the key ("u is down" is not "U is down")
+    return [h + ("" if h.endswith(".") else ".") for h in hooks]
+
+
+@cache
+def meanings() -> list[tuple[str, str]]:
+    """Single-letter keys with a one-word meaning: (c, change), (d, delete) ..."""
+    data = yaml.safe_load((resources.files("vimniscient") / "mnemonics.yaml").read_text(encoding="utf-8"))
+    known = {s.removesuffix(".") for s in sentences()}
+    return [(key, entry["means"]) for key, entry in data.items() if entry["hook"].removesuffix(".") in known
+            and re.fullmatch(r"[a-zA-Z]", key) and re.fullmatch(r"[a-z]+", entry.get("means") or "")]
+
+
+_WORD = re.compile(r"(?<![\w'.-])[A-Za-z]{4,}(?![\w'-])")
+
+
+def _words(sentence: str, spaced: bool) -> list[re.Match]:
+    """Plain words of four letters or more; `spaced` wants a space on both sides (a WORD)."""
+    found = list(_WORD.finditer(sentence))
+    if spaced:
+        found = [m for m in found if m.start() > 0 and sentence[m.start() - 1] == " "
+                 and m.end() < len(sentence) and sentence[m.end()] == " "]
+    else:  # daw and ciw want the word to have a space after it, or anything but a letter
+        found = [m for m in found if m.end() < len(sentence)]
+    return found
+
+
+def _gaps(sentence: str) -> list[int]:
+    """Where a new word can go: the start of every word but the first."""
+    return [m.end() for m in re.finditer(r" (?=[A-Za-z])", sentence)]
+
+
+def _ci_quote(rng: random.Random) -> dict:
+    (key, right), (_, wrong) = rng.sample(meanings(), 2)
+    start = f'{key}_means = "{wrong}"'
+    return dict(goal=f'{key} stands for {right}: fix the string.', start=[start], cursor=(1, rng.randrange(len(start) - 1)),
+                target=[f'{key}_means = "{right}"'], solution=f'ci"{right}<Esc>',
+                hint='ci" changes what is inside the quotes, and finds them from anywhere before them.')
+
+
+def _paren(rng: random.Random, around: bool) -> dict:
+    name = rng.choice(("around", "parens") if around else ("inner", "inside"))
+    args = ", ".join(means for _, means in rng.sample(meanings(), 3))
+    start = f"{name}({args}) + 1"
+    target, keys = (f"{name} + 1", "da(") if around else (f"{name}() + 1", "di(")
+    what = "the call's parentheses and arguments" if around else "the arguments, keeping the parentheses"
+    return dict(goal=f"Delete {what}.", start=[start], cursor=(1, len(name) + 1 + rng.randrange(len(args))), target=[target],
+                solution=keys, hint=f"{keys} works from anywhere inside the parentheses.")
+
+
+def _di_bracket(rng: random.Random) -> dict:
+    name = rng.choice(("keys", "square", "bracket"))
+    items = ", ".join(f'"{key}"' for key, _ in rng.sample(meanings(), 3))
+    start = f"{name} = [{items}]"
+    return dict(goal="Empty the list, keeping the square brackets.", start=[start], cursor=(1, len(name) + 4 + rng.randrange(len(items))),
+                target=[f"{name} = []"], solution="di[", hint="[ names the square brackets: di[ empties them.")
+
+
+def _dt_letter(rng: random.Random) -> dict:
+    filler = " ".join(rng.sample(FILLER, 2)) + " "
+    while True:
+        sentence = rng.choice(sentences())
+        gaps = [g for g in _gaps(sentence) if sentence[g] not in filler]
+        if gaps:
+            break
+    gap = rng.choice(gaps)
+    word = sentence[gap:].split(" ")[0].rstrip(".,:;")
+    letter = word[0]
+    return dict(goal=f'Delete everything up to "{word}".', start=[sentence[:gap] + filler + sentence[gap:]], cursor=(1, gap),
+                target=[sentence], solution=f"dt{letter}", hint=f"dt{letter} deletes till the next {letter}, and stops just before it.")
+
+
+def _d_rest(rng: random.Random) -> dict:
+    sentence = rng.choice(sentences())
+    return dict(goal="Delete the filler after the full stop.", start=[f"{sentence} {' '.join(rng.sample(FILLER, 3))}"],
+                cursor=(1, len(sentence)), target=[sentence], solution="D", hint="D is a big d: it deletes to the end of the line.")
+
+
+def _j_split(rng: random.Random) -> dict:
+    sentence = rng.choice([s for s in sentences() if _gaps(s)])
+    gap = rng.choice(_gaps(sentence))
+    return dict(goal="Join the two lines.", start=[sentence[:gap - 1], sentence[gap:]], cursor=(1, 0), target=[sentence],
+                solution="J", hint="J joins this line and the next, with one space.")
+
+
+def _ddp_swap(rng: random.Random) -> dict:
+    first, second = rng.sample(sentences(), 2)
+    return dict(goal="Swap the two lines.", start=[first, second], cursor=(1, 0), target=[second, first],
+                solution="ddp", hint="dd cuts the line, p puts it below the next one.")
+
+
+def _count_dw(rng: random.Random) -> dict:
+    n = rng.randint(2, 4)
+    sentence = rng.choice([s for s in sentences() if _gaps(s)])
+    gap = rng.choice(_gaps(sentence))
+    filler = " ".join(rng.choice(FILLER) for _ in range(n)) + " "
+    return dict(goal=f"Delete the {n} filler words.", start=[sentence[:gap] + filler + sentence[gap:]], cursor=(1, gap),
+                target=[sentence], solution=f"{n}dw", hint=f"A count repeats the verb: {n}dw deletes {n} words.")
+
+
+def _count_dd(rng: random.Random) -> dict:
+    n = rng.randint(2, 4)
+    first, last = rng.sample(sentences(), 2)
+    return dict(goal=f"Delete the {n} filler lines.", start=[first, *[rng.choice(FILLER) for _ in range(n)], last], cursor=(2, 0),
+                target=[first, last], solution=f"{n}dd", hint=f"A count works on dd: {n}dd deletes {n} lines.")
+
+
+def _count_x(rng: random.Random) -> dict:
+    n = rng.randint(2, 7)
+    sentence = rng.choice([s for s in sentences() if _gaps(s)])
+    gap = rng.choice(_gaps(sentence))
+    return dict(goal=f"Delete the {n} x letters.", start=[sentence[:gap] + "x" * n + sentence[gap:]], cursor=(1, gap),
+                target=[sentence], solution=f"{n}x", hint=f"x crosses out a character; {n}x crosses out {n}.")
+
+
+MAKERS = {
+    "ci-quote": _ci_quote,
+    "di-paren": lambda rng: _paren(rng, around=False),
+    "da-paren": lambda rng: _paren(rng, around=True),
+    "di-bracket": _di_bracket,
+    "dt-letter": _dt_letter,
+    "D-rest": _d_rest,
+    "J-split": _j_split,
+    "ddp-swap": _ddp_swap,
+    "count-dw": _count_dw,
+    "count-dd": _count_dd,
+    "count-x": _count_x,
+}
+KINDS = ("ciw-typo", "daw-double", "ciW-dotted", *MAKERS)
+
+
+def generate(kind: str, seed: str, parent: Task) -> Task:
+    """A `kind` task from `seed`, with the parent task's hint and place in its lesson."""
+    rng = random.Random(f"{kind}:{seed}")
+    if kind in MAKERS:
+        return replace(parent, ft="", variants=[], generated=seed, **MAKERS[kind](rng))
+    while True:
+        sentence = rng.choice(sentences())
+        words = _words(sentence, spaced=kind == "ciW-dotted")
+        if kind == "daw-double":
+            words = [m for m in words if sentence[m.end()] == " "]
+        if kind == "ciw-typo":
+            words = [m for m in words if len(set(m.group()[1:-1])) > 1]
+        if words:
+            break
+    m = rng.choice(words)
+    word, before, after = m.group(), sentence[: m.start()], sentence[m.end():]
+    if kind == "ciw-typo":
+        while True:
+            i = rng.randrange(1, len(word) - 2)
+            if word[i] != word[i + 1]:
+                break
+        shown = word[:i] + word[i + 1] + word[i] + word[i + 2:]
+        start, cursor = before + shown + after, len(before) + rng.randrange(len(shown))
+        goal, solution = f'Fix "{shown}" to "{word}".', f"ciw{word}<Esc>"
+    elif kind == "daw-double":
+        start = before + word + " " + word + after
+        cursor = len(before) + rng.choice([0, len(word) + 1]) + rng.randrange(len(word))
+        goal, solution = f'Delete the doubled "{word}".', "daw"
+    elif kind == "ciW-dotted":
+        shown = ".".join(word)
+        start, cursor = before + shown + after, len(before) + rng.randrange(len(shown))
+        goal, solution = f'Write the dotted "{shown}" as "{word}".', f"ciW{word}<Esc>"
+    else:
+        raise ValueError(f"no generator called {kind}")
+    return replace(parent, goal=goal, start=[start], cursor=(1, cursor), target=[sentence],
+                   solution=solution, ft="", variants=[], generated=seed)

{vimniscient-0.2.0 → vimniscient-0.2.2}/src/vimniscient/habits.py

@@ -15,6 +15,7 @@ from pathlib import Path
 
 from vimniscient.cards import Card, Deck
 from vimniscient.keys import split_keys
+from vimniscient.mnemonics import OPERATORS
 
 LOG = Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local/state")) / "nvim" / "hardtime.nvim.log"
 
@@ -91,7 +92,7 @@ def habit_deck() -> Deck:
                 answers=[better],
                 style="keys",
                 case_sensitive=True,
-                note=f"hardtime caught this {habit.total}×.",
+                note=f"{'Verb first, then the motion. ' if better[0] in OPERATORS else ''}hardtime caught this {habit.total}×.",
                 order=i,
             )
         )

{vimniscient-0.2.0 → vimniscient-0.2.2}/src/vimniscient/lessons/sources.md

@@ -1,8 +1,8 @@
 # Sources for the facts in the lesson texts
 
-The lesson texts are mnemonic: they describe the key being practised (see
-`../mnemonics.yaml`), and the rest is about the science of learning and memory.
-Every factual claim in them should trace back to one of these.
+Lesson practice texts are mnemonic: each one is about the keys it practises (see
+`../mnemonics.yaml`). Memory science belongs in lesson intros, where it explains
+why the training works. Every factual claim there should trace back to one of these.
 
 - **Atkinson & Raugh (1975).** An application of the mnemonic keyword method to
   the acquisition of a Russian vocabulary. *JEP: Human Learning and Memory*

{vimniscient-0.2.0 → vimniscient-0.2.2}/src/vimniscient/lessons/w1d1-words.yaml

@@ -1,6 +1,7 @@
 week: 1
 day: 1
 title: Word text objects
+skill: text-objects
 intro: |
   Read a Vim command as a small sentence: a verb, then a noun. The verbs are
   `c` *change*, `d` *delete* and `y` *yank* (Vim's old word for copy). The noun
@@ -32,12 +33,6 @@ tasks:
         target: |-
           Change inner word: c is the verb, iw the noun, and the cursor sits anywhere in it.
         solution: 'ciwanywhere<Esc>'
-      - goal: 'Fix "memroy" to "memory" (the cursor is in the middle of the word).'
-        start: |-
-          Testing yourself beats rereading: type ciw from mem▮roy, not from the page.
-        target: |-
-          Testing yourself beats rereading: type ciw from memory, not from the page.
-        solution: 'ciwmemory<Esc>'
       - goal: 'Fix "undersocres" to "underscores" (the cursor is in the middle of the word).'
         start: |-
           In ciw, the w is a word: letters, digits and under▮socres, nothing else.
@@ -64,11 +59,6 @@ tasks:
           daw takes a word and what is around it, its ▮its trailing space.
         target: |-
           daw takes a word and what is around it, its trailing space.
-      - goal: 'Delete one "himself".'
-        start: |-
-          Ebbinghaus tested ▮himself himself on nonsense syllables; daw cuts the echo.
-        target: |-
-          Ebbinghaus tested himself on nonsense syllables; daw cuts the echo.
       - goal: 'Delete one "so".'
         start: |-
           With daw, a means around: the word goes, and ▮so so does one space.
@@ -101,12 +91,6 @@ tasks:
         target: |-
           ciW sees a path as one WORD, slashes and all.
         solution: 'ciWa path<Esc>'
-      - goal: 'Replace "Fitts&Posner(1967)" with "Fitts-and-Posner".'
-        start: |-
-          ciW: from space to space, Fitts&Pos▮ner(1967) counts as one WORD.
-        target: |-
-          ciW: from space to space, Fitts-and-Posner counts as one WORD.
-        solution: 'ciWFitts-and-Posner<Esc>'
   - goal: 'Spell the function name out as change_inner_word.'
     ft: python
     start: |-
@@ -180,18 +164,6 @@ tasks:
         target: |-
           viwp swaps a selection for the yank, so select, then put the yank
         solution: 'yiw$viwp'
-      - goal: 'Copy "spaced" over "massed".'
-        start: |-
-          ▮spaced reviews beat massed ones, so keep them massed
-        target: |-
-          spaced reviews beat massed ones, so keep them spaced
-        solution: 'yiw$viwp'
-      - goal: 'Copy "mixed" over the last "blocked".'
-        start: |-
-          Rohrer and Taylor: blocked practice feels better than ▮mixed, yet scores below blocked
-        target: |-
-          Rohrer and Taylor: blocked practice feels better than mixed, yet scores below mixed
-        solution: 'yiw$viwp'
   - goal: 'Delete the doubled "the".'
     start: |-
       daw: delete a word, and ▮the the space after it.
@@ -206,16 +178,6 @@ tasks:
           Doubled words ▮like like this one are what daw is for.
         target: |-
           Doubled words like this one are what daw is for.
-      - goal: 'Delete the doubled "four".'
-        start: |-
-          Cowan put short-term memory at about ▮four four chunks.
-        target: |-
-          Cowan put short-term memory at about four chunks.
-      - goal: 'Delete the doubled "familiar".'
-        start: |-
-          Rereading builds a fluency illusion: the text feels ▮familiar familiar, not known.
-        target: |-
-          Rereading builds a fluency illusion: the text feels familiar, not known.
       - goal: 'Delete the doubled "and".'
         start: |-
           daw: d for delete, a for a word ▮and and its space.