vimniscient 0.2.1__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vimniscient
-Version: 0.2.1
+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.1 → 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.1 → vimniscient-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vimniscient"
-version = "0.2.1"
+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.1 → 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.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.1 → 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.1 → 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

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w1d2-pairs.yaml

@@ -1,6 +1,7 @@
 week: 1
 day: 2
 title: Quotes, brackets and tags
+skill: text-objects
 intro: |
   The same `i`/`a` trick works on pairs, and the noun is simply the pair's own
   sign: `i"` is inside the quotes, `a"` takes the quotes too. Brackets name
@@ -10,6 +11,7 @@ intro: |
 keys: ['ci"', 'da"', 'di(', 'da(', 'di[', 'cit']
 tasks:
   - goal: 'Set the string to "change inside".'
+    generate: ci-quote
     ft: python
     start: |-
       ci_quote = "▮delete outside"
@@ -31,6 +33,7 @@ tasks:
           inner_quote = "without the quotes"
         solution: 'ci"without the quotes<Esc>'
   - goal: 'Change the string to "the quotes", starting from the beginning of the line.'
+    generate: ci-quote
     ft: python
     start: |-
       ▮ci_quote_keeps = "nothing"
@@ -46,6 +49,7 @@ tasks:
           ci_quote_finds = "the next quotes"
         solution: 'ci"the next quotes<Esc>'
   - goal: 'Empty the inner parentheses.'
+    generate: di-paren
     ft: python
     start: |-
       di_paren(empties(▮this_part))
@@ -59,6 +63,7 @@ tasks:
         target: |-
           inner_paren(keeps())
   - goal: 'Delete the argument list, parentheses included.'
+    generate: da-paren
     ft: python
     start: |-
       da = deletes(▮around, it) + parens
@@ -72,6 +77,7 @@ tasks:
         target: |-
           parens_go = da + too
   - goal: 'Empty the list.'
+    generate: di-bracket
     ft: python
     start: |-
       di_bracket_leaves = [▮"just", "the", "brackets"]

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w1d3-sentences.yaml

@@ -1,6 +1,7 @@
 week: 1
 day: 3
 title: Sentences and paragraphs
+skill: text-objects
 intro: |
   Bigger nouns: `s` is a *sentence* and `p` a *paragraph* (a block of lines
   between empty lines). `is`/`ip` are the thing itself; `as`/`ap` take the

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w1d4-find.yaml

@@ -1,6 +1,7 @@
 week: 1
 day: 4
 title: Find and till on a line
+skill: motions
 intro: |
   `f{char}` *finds* the next {char} on the line and lands *on* it; `t{char}`
   goes *till* it and stops just before. Capital `F` and `T` look backwards.
@@ -10,6 +11,7 @@ intro: |
 keys: [f, t, F, T, ";", ",", dt, ct]
 tasks:
   - goal: 'Delete everything up to "just".'
+    generate: dt-letter
     start: |-
       t means till: it stops ▮way way just before the letter.
     target: |-

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w1d5-lines.yaml

@@ -1,6 +1,7 @@
 week: 1
 day: 5
 title: Whole lines and line ends
+skill: edits
 intro: |
   Capitals go big: `D` deletes to the end of the line, `C` changes to the end.
   Doubling a verb means the whole line: `dd` deletes it, `cc` changes it. `J`
@@ -10,6 +11,7 @@ intro: |
 keys: [D, C, cc, dd, J, ddp, A, I]
 tasks:
   - goal: 'Delete the rest of the line.'
+    generate: D-rest
     start: |-
       D is a big d: it deletes to the end.▮ Everything after the cursor goes.
     target: |-
@@ -62,6 +64,7 @@ tasks:
           yy yanks a line
         solution: 'cccc changes a line<Esc>'
   - goal: 'Join the two lines.'
+    generate: J-split
     start: |-
       ▮J joins this line
       and the next one.
@@ -76,6 +79,7 @@ tasks:
         target: |-
           gJ joins with no space; J adds one.
   - goal: 'Put the steps in order: delete first.'
+    generate: ddp-swap
     start: |-
       ▮then p puts
       dd deletes

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w1d6-counts.yaml

@@ -1,6 +1,7 @@
 week: 1
 day: 6
 title: Counts
+skill: motions
 intro: |
   A number in front repeats the command, and it reads like a numeral before a
   noun: `3dw` *delete three words*, `3dd` three lines, `5x` cross out five
@@ -11,6 +12,7 @@ intro: |
 keys: [3dw, 3dd, c2w, 5x, "3f,", 3J, 4j, 3k]
 tasks:
   - goal: 'Delete the three words "one two three".'
+    generate: count-dw
     start: |-
       A count repeats: 3dw ▮one two three deletes three words.
     target: |-
@@ -24,6 +26,7 @@ tasks:
         target: |-
           A count before dw repeats it.
   - goal: 'Delete the three middle lines.'
+    generate: count-dd
     start: |-
       3dd deletes
       ▮this line,
@@ -61,6 +64,7 @@ tasks:
           c2w: change two words.
         solution: 'c2wtwo words<Esc>'
   - goal: 'Fix the number: 5, not 500000.'
+    generate: count-x
     start: |-
       The count is 5▮00000, and x goes five times.
     target: |-

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w1d7-review.yaml

@@ -2,6 +2,7 @@ week: 1
 day: 7
 review: true
 title: Week 1 review
+skill: mixed
 intro: |
   A mix of everything from this week. Try each one before reaching for
   `:Hint`, and try to match the reference keystroke count. Mixing topics like

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w2d1-dot.yaml

@@ -1,6 +1,7 @@
 week: 2
 day: 1
 title: The dot command
+skill: repeats
 intro: |
   `.` repeats your last change: the whole thing, including the text you
   typed in insert mode. Read it as a full stop that says *again*. Make one

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w2d2-search.yaml

@@ -1,6 +1,7 @@
 week: 2
 day: 2
 title: Searching as a motion
+skill: search
 intro: |
   `/text<Enter>` jumps to the next match (the slash leans forward),
   `?text<Enter>` to the previous one (a question asks back). `n` repeats it,

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w2d3-cgn.yaml

@@ -1,6 +1,7 @@
 week: 2
 day: 3
 title: The cgn trick
+skill: repeats
 intro: |
   `gn` reads as *go to the next match* and grab it: it selects the next
   search match. So `cgn` changes the next match, and `.` then changes the one

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w2d4-case-numbers.yaml

@@ -1,6 +1,7 @@
 week: 2
 day: 4
 title: Case and numbers
+skill: edits
 intro: |
   `~` flips the case of one character: the tilde is a little wave. `gU`, `gu`
   and `g~` are operators: U is *up* (capitals), u is down. `gUiw` uppercases

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w2d5-insert.yaml

@@ -1,6 +1,7 @@
 week: 2
 day: 5
 title: Getting into insert mode well
+skill: edits
 intro: |
   Choosing the right way into insert mode saves moving first: `o`/`O` *open*
   a line below/above, `ea` goes to the *end* of a word and *appends*, `R`

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w2d6-visual.yaml

@@ -1,6 +1,7 @@
 week: 2
 day: 6
 title: Visual mode
+skill: visual
 intro: |
   `v` is *visual*: you see what you'll act on. `v` selects characters,
   capital `V` whole lines. Move to grow the selection, then give an operator:

{vimniscient-0.2.1 → vimniscient-0.2.2}/src/vimniscient/lessons/w2d7-review.yaml

@@ -2,6 +2,7 @@ week: 2
 day: 7
 review: true
 title: Week 2 review
+skill: mixed
 intro: |
   Dot, search, cgn, case, numbers and visual mode, mixed. Look for the
   shortest route before you start typing. Each retrieval you do now, a few