codetype 1.0.0

package/README.md

@@ -0,0 +1,55 @@
+# CodeType
+
+Offline terminal code-typing practice game. Pure Python stdlib (curses) — no network, no heavy deps.
+
+## Install & run
+
+With [pipx](https://pipx.pypa.io) (recommended — gives you the `codetype` command everywhere):
+
+```sh
+pipx install git+https://github.com/rohan4naik/codetype-cli
+codetype
+```
+
+Or with pip from a clone:
+
+```sh
+git clone https://github.com/rohan4naik/codetype-cli
+cd codetype-cli
+pip install .
+codetype
+```
+
+Or no install at all — run straight from the clone:
+
+```sh
+python3 -m codetype
+```
+
+Windows: `pip install .` pulls in `windows-curses` automatically.
+
+## How it works
+
+- Pick a language from the menu (python / javascript / typescript / c / go / rust / java / sql / bash / random).
+- Or pick **sentences (speed test)** — a fresh block of random common words every run, for raw typing speed. Space or Enter both work at line wraps.
+- Type the snippet exactly. Correct chars turn green, mistakes show red and must be backspaced before you can continue.
+- Press Enter at end of line — leading indentation of the next line is auto-skipped (shown dim, not counted toward WPM).
+- Live WPM, accuracy, and timer in the header. Timer starts on your first keystroke.
+- `history` in the menu shows your last 15 runs and per-language bests.
+
+## Keys
+
+| Key | Action |
+|---|---|
+| Tab | Restart current snippet |
+| Esc | Back to menu / quit |
+| Backspace | Fix mistake |
+| Enter (results) | Next snippet |
+
+## Stats
+
+Every completed run is appended to `~/.codetype/stats.json` (WPM, accuracy, errors, time, date). Results screen shows your per-language best.
+
+## Adding snippets
+
+Edit `codetype/snippets.py` — append strings to any language list or add a new language key. Use spaces for indentation, not tabs.

package/bin/codetype.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+const pkgRoot = path.resolve(__dirname, "..");
+
+function findPython() {
+  const candidates =
+    process.platform === "win32"
+      ? ["python", "python3", "py"]
+      : ["python3", "python"];
+  for (const cmd of candidates) {
+    const check = spawnSync(cmd, ["-c", "import sys; sys.exit(0 if sys.version_info >= (3, 8) else 1)"], {
+      stdio: "ignore",
+    });
+    if (check.status === 0) return cmd;
+  }
+  return null;
+}
+
+const python = findPython();
+if (!python) {
+  console.error("codetype requires Python 3.8+ but none was found on your PATH.");
+  console.error("Install it from https://www.python.org/downloads/ and try again.");
+  process.exit(1);
+}
+
+const env = { ...process.env };
+env.PYTHONPATH = env.PYTHONPATH
+  ? pkgRoot + path.delimiter + env.PYTHONPATH
+  : pkgRoot;
+
+const result = spawnSync(python, ["-m", "codetype", ...process.argv.slice(2)], {
+  stdio: "inherit",
+  env,
+});
+
+if (result.error) {
+  console.error("Failed to launch Python:", result.error.message);
+  process.exit(1);
+}
+
+if (process.platform === "win32" && result.status !== 0) {
+  console.error("");
+  console.error("If you saw a curses import error, run: pip install windows-curses");
+}
+
+process.exit(result.status === null ? 1 : result.status);

package/codetype/__main__.py

@@ -0,0 +1,3 @@
+from .game import run
+
+run()

package/codetype/game.py

@@ -0,0 +1,503 @@
+#!/usr/bin/env python3
+"""CodeType — offline terminal code-typing practice game.
+
+Run:  codetype  (after pip/pipx install)  or  python3 -m codetype
+
+Keys in-game:
+  type the code   progress
+  Enter           newline (leading indent auto-skips)
+  Backspace       fix mistakes
+  Tab             restart current snippet
+  Esc             back to menu
+"""
+
+import curses
+import json
+import locale
+import os
+import random
+import time
+
+locale.setlocale(locale.LC_ALL, "")
+
+from .snippets import SNIPPETS, random_sentence_test
+
+STATS_PATH = os.path.join(os.path.expanduser("~"), ".codetype", "stats.json")
+
+# color pair ids
+C_CORRECT = 1
+C_WRONG = 2
+C_PENDING = 3
+C_CURSOR = 4
+C_TITLE = 5
+C_DIM = 6
+
+
+def init_colors():
+    curses.start_color()
+    curses.use_default_colors()
+    curses.init_pair(C_CORRECT, curses.COLOR_GREEN, -1)
+    curses.init_pair(C_WRONG, curses.COLOR_WHITE, curses.COLOR_RED)
+    curses.init_pair(C_PENDING, curses.COLOR_WHITE, -1)
+    curses.init_pair(C_CURSOR, curses.COLOR_BLACK, curses.COLOR_YELLOW)
+    curses.init_pair(C_TITLE, curses.COLOR_CYAN, -1)
+    curses.init_pair(C_DIM, curses.COLOR_WHITE, -1)
+
+
+def load_stats():
+    try:
+        with open(STATS_PATH) as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {"runs": []}
+
+
+def save_run(lang, wpm, accuracy, chars, seconds):
+    stats = load_stats()
+    stats["runs"].append({
+        "lang": lang,
+        "wpm": round(wpm, 1),
+        "accuracy": round(accuracy, 1),
+        "chars": chars,
+        "seconds": round(seconds, 1),
+        "when": time.strftime("%Y-%m-%d %H:%M"),
+    })
+    os.makedirs(os.path.dirname(STATS_PATH), exist_ok=True)
+    with open(STATS_PATH, "w") as f:
+        json.dump(stats, f, indent=2)
+    return stats
+
+
+def best_wpm(stats, lang):
+    runs = [r["wpm"] for r in stats["runs"] if r["lang"] == lang]
+    return max(runs) if runs else 0.0
+
+
+# ANSI-shadow letters for the menu banner
+ANSI_LETTERS = {
+    "C": [" ██████╗", "██╔════╝", "██║     ", "██║     ", "╚██████╗", " ╚═════╝"],
+    "O": [" ██████╗ ", "██╔═══██╗", "██║   ██║", "██║   ██║", "╚██████╔╝", " ╚═════╝ "],
+    "D": ["██████╗ ", "██╔══██╗", "██║  ██║", "██║  ██║", "██████╔╝", "╚═════╝ "],
+    "E": ["███████╗", "██╔════╝", "█████╗  ", "██╔══╝  ", "███████╗", "╚══════╝"],
+    "T": ["████████╗", "╚══██╔══╝", "   ██║   ", "   ██║   ", "   ██║   ", "   ╚═╝   "],
+    "Y": ["██╗   ██╗", "╚██╗ ██╔╝", " ╚████╔╝ ", "  ╚██╔╝  ", "   ██║   ", "   ╚═╝   "],
+    "P": ["██████╗ ", "██╔══██╗", "██████╔╝", "██╔═══╝ ", "██║     ", "╚═╝     "],
+}
+
+
+def banner_lines(word="CODETYPE"):
+    return ["".join(ANSI_LETTERS[c][row] for c in word) for row in range(6)]
+
+
+BIG_FONT = {
+    "0": ["███", "█ █", "█ █", "█ █", "███"],
+    "1": [" █ ", "██ ", " █ ", " █ ", "███"],
+    "2": ["███", "  █", "███", "█  ", "███"],
+    "3": ["███", "  █", "███", "  █", "███"],
+    "4": ["█ █", "█ █", "███", "  █", "  █"],
+    "5": ["███", "█  ", "███", "  █", "███"],
+    "6": ["███", "█  ", "███", "█ █", "███"],
+    "7": ["███", "  █", "  █", "  █", "  █"],
+    "8": ["███", "█ █", "███", "█ █", "███"],
+    "9": ["███", "█ █", "███", "  █", "███"],
+    ".": ["  ", "  ", "  ", "  ", "█ "],
+}
+
+
+def big_text_width(s):
+    return sum(len(BIG_FONT[c][0]) for c in s) + len(s) - 1
+
+
+def draw_big_text(win, y, x, s, attr=0):
+    """Render digits/dot as 5-row block characters."""
+    for row in range(5):
+        cx = x
+        for c in s:
+            glyph = BIG_FONT[c][row]
+            addstr_safe(win, y + row, cx, glyph, attr)
+            cx += len(glyph) + 1
+
+
+def addstr_safe(win, y, x, text, attr=0):
+    """addstr that ignores writes outside the window instead of crashing."""
+    h, w = win.getmaxyx()
+    if 0 <= y < h and x < w:
+        try:
+            win.addstr(y, x, text[: max(0, w - x)], attr)
+        except curses.error:
+            pass
+
+
+class Menu:
+    """Simple arrow-key vertical menu. Returns chosen index, or None on Esc."""
+
+    def __init__(self, stdscr, title, options, footer="", banner=None, tagline=""):
+        self.stdscr = stdscr
+        self.title = title
+        self.options = options
+        self.footer = footer
+        self.banner = banner or []
+        self.tagline = tagline
+
+    def run(self):
+        idx = 0
+        while True:
+            self.stdscr.erase()
+            h, w = self.stdscr.getmaxyx()
+
+            bw = max((len(l) for l in self.banner), default=0)
+            use_banner = (self.banner and w >= bw + 2
+                          and h >= len(self.banner) + len(self.options) + 8)
+            if use_banner:
+                by = max(1, (h - (len(self.banner) + len(self.options) + 5)) // 2)
+                for i, line in enumerate(self.banner):
+                    addstr_safe(self.stdscr, by + i, max(0, (w - bw) // 2), line,
+                                curses.color_pair(C_TITLE) | curses.A_BOLD)
+                if self.tagline:
+                    addstr_safe(self.stdscr, by + len(self.banner) + 1,
+                                max(0, (w - len(self.tagline)) // 2),
+                                self.tagline, curses.A_DIM)
+                top = by + len(self.banner) + 3
+            else:
+                top = max(1, h // 2 - len(self.options) // 2 - 2)
+                addstr_safe(self.stdscr, top - 2, max(0, (w - len(self.title)) // 2),
+                            self.title, curses.color_pair(C_TITLE) | curses.A_BOLD)
+
+            for i, opt in enumerate(self.options):
+                attr = curses.color_pair(C_CURSOR) if i == idx else curses.A_NORMAL
+                label = f"  {opt}  "
+                addstr_safe(self.stdscr, top + i, max(0, (w - len(label)) // 2), label, attr)
+            if self.footer:
+                addstr_safe(self.stdscr, h - 2, max(0, (w - len(self.footer)) // 2),
+                            self.footer, curses.A_DIM)
+            self.stdscr.refresh()
+
+            key = self.stdscr.getch()
+            if key in (curses.KEY_UP, ord("k")):
+                idx = (idx - 1) % len(self.options)
+            elif key in (curses.KEY_DOWN, ord("j")):
+                idx = (idx + 1) % len(self.options)
+            elif key in (curses.KEY_ENTER, 10, 13):
+                return idx
+            elif key == 27:  # Esc
+                return None
+
+
+class TypingGame:
+    RESULT_QUIT, RESULT_MENU, RESULT_RESTART, RESULT_DONE = range(4)
+
+    def __init__(self, stdscr, lang, text):
+        self.stdscr = stdscr
+        self.lang = lang
+        self.text = text
+        self.lines = text.split("\n")
+        # In sentence mode line breaks are soft wraps, so space works as Enter.
+        self.space_as_newline = lang == "sentences"
+        self.reset()
+
+    def reset(self):
+        self.pos = 0                    # index into self.text
+        self.wrong = []                 # stack of wrongly-typed chars (shown in red)
+        self.auto = set()               # positions filled by auto-indent (not user keystrokes)
+        self.keystrokes = 0             # user keystrokes that produced a char
+        self.errors = 0                 # keystrokes that were wrong
+        self.start_time = None
+
+    # --- coordinates ---------------------------------------------------
+
+    def pos_to_rowcol(self, pos):
+        """Map an index in self.text to (line, column)."""
+        consumed = 0
+        for row, line in enumerate(self.lines):
+            if pos <= consumed + len(line):
+                return row, pos - consumed
+            consumed += len(line) + 1  # +1 for the newline
+        last = len(self.lines) - 1
+        return last, len(self.lines[last])
+
+    # --- typing logic --------------------------------------------------
+
+    def skip_auto_indent(self):
+        """After a correct newline, auto-fill the next line's leading spaces."""
+        while self.pos < len(self.text) and self.text[self.pos] == " ":
+            row, col = self.pos_to_rowcol(self.pos)
+            stripped = len(self.lines[row]) - len(self.lines[row].lstrip(" "))
+            if col >= stripped:
+                break
+            self.auto.add(self.pos)
+            self.pos += 1
+
+    def handle_key(self, key):
+        """Returns True when the snippet is finished."""
+        if key in (curses.KEY_BACKSPACE, 127, 8):
+            if self.wrong:
+                self.wrong.pop()
+            elif self.pos > 0:
+                self.pos -= 1
+                while self.pos > 0 and self.pos in self.auto:
+                    self.auto.discard(self.pos)
+                    self.pos -= 1
+                self.auto.discard(self.pos)
+            return False
+
+        if key in (curses.KEY_ENTER, 10, 13):
+            ch = "\n"
+        elif 32 <= key <= 126:
+            ch = chr(key)
+        else:
+            return False  # ignore other control keys
+
+        if self.start_time is None:
+            self.start_time = time.time()
+        self.keystrokes += 1
+
+        expected = self.text[self.pos] if self.pos < len(self.text) else None
+        matches = ch == expected or (
+            self.space_as_newline and expected == "\n" and ch == " "
+        )
+        if not self.wrong and matches:
+            self.pos += 1
+            if expected == "\n":
+                self.skip_auto_indent()
+        else:
+            self.errors += 1
+            if len(self.wrong) < 10:  # cap runaway error trains
+                self.wrong.append(ch)
+
+        return self.pos >= len(self.text) and not self.wrong
+
+    # --- stats ---------------------------------------------------------
+
+    def elapsed(self):
+        return (time.time() - self.start_time) if self.start_time else 0.0
+
+    def wpm(self):
+        secs = self.elapsed()
+        if secs <= 0:
+            return 0.0
+        typed = self.pos - len([p for p in self.auto if p < self.pos])
+        return (typed / 5) / (secs / 60)
+
+    def accuracy(self):
+        if self.keystrokes == 0:
+            return 100.0
+        return 100.0 * (self.keystrokes - self.errors) / self.keystrokes
+
+    # --- rendering -----------------------------------------------------
+
+    def draw(self):
+        self.stdscr.erase()
+        h, w = self.stdscr.getmaxyx()
+
+        header = (f" {self.lang}   WPM {self.wpm():5.1f}   "
+                  f"ACC {self.accuracy():5.1f}%   TIME {self.elapsed():5.1f}s ")
+        addstr_safe(self.stdscr, 0, 1, header, curses.color_pair(C_TITLE) | curses.A_BOLD)
+
+        # Double line-height and bold when the terminal has room, since
+        # curses cannot change the actual font size.
+        xstep = 1
+        ystep = 2 if h >= 14 else 1
+
+        cur_row, cur_col = self.pos_to_rowcol(self.pos)
+        view_h = max(1, (h - 4) // ystep)
+        first = max(0, min(cur_row - view_h // 2, len(self.lines) - view_h))
+
+        consumed = sum(len(l) + 1 for l in self.lines[:first])
+        for screen_row, row in enumerate(range(first, min(len(self.lines), first + view_h))):
+            line = self.lines[row]
+            y = 2 + screen_row * ystep
+            for col, ch in enumerate(line):
+                p = consumed + col
+                if p < self.pos:
+                    attr = (curses.A_DIM if p in self.auto
+                            else curses.color_pair(C_CORRECT) | curses.A_BOLD)
+                elif p == self.pos and not self.wrong:
+                    attr = curses.color_pair(C_CURSOR) | curses.A_BOLD
+                else:
+                    attr = curses.A_BOLD
+                addstr_safe(self.stdscr, y, 2 + col * xstep, ch, attr)
+            # newline cursor marker at end of line
+            p = consumed + len(line)
+            if p == self.pos and not self.wrong and row < len(self.lines) - 1:
+                addstr_safe(self.stdscr, y, 2 + len(line) * xstep, "⏎",
+                            curses.color_pair(C_CURSOR) | curses.A_BOLD)
+            consumed += len(line) + 1
+
+        if self.wrong:
+            wy = 2 + (cur_row - first) * ystep
+            for i, c in enumerate(self.wrong):
+                shown = "⏎" if c == "\n" else c
+                addstr_safe(self.stdscr, wy, 2 + (cur_col + i) * xstep,
+                            shown, curses.color_pair(C_WRONG) | curses.A_BOLD)
+
+        addstr_safe(self.stdscr, h - 1, 1,
+                    "Tab restart   Esc menu   Backspace fix", curses.A_DIM)
+        self.stdscr.refresh()
+
+    # --- main loop -------------------------------------------------------
+
+    def run(self):
+        self.stdscr.nodelay(True)
+        try:
+            while True:
+                self.draw()
+                key = self.stdscr.getch()
+                if key == -1:
+                    time.sleep(0.03)
+                    continue
+                if key == 27:
+                    return self.RESULT_MENU
+                if key == 9:  # Tab
+                    return self.RESULT_RESTART
+                if key == curses.KEY_RESIZE:
+                    continue
+                if self.handle_key(key):
+                    return self.RESULT_DONE
+        finally:
+            self.stdscr.nodelay(False)
+
+
+def show_results(stdscr, game):
+    secs = game.elapsed()
+    wpm = game.wpm()
+    acc = game.accuracy()
+    stats = save_run(game.lang, wpm, acc, len(game.text), secs)
+    best = best_wpm(stats, game.lang)
+    is_best = wpm >= best
+
+    stdscr.erase()
+    h, w = stdscr.getmaxyx()
+    top = max(1, h // 2 - 9)
+
+    title = "S N I P P E T   C O M P L E T E"
+    addstr_safe(stdscr, top, max(0, (w - len(title)) // 2), title,
+                curses.color_pair(C_TITLE) | curses.A_BOLD)
+
+    big = f"{wpm:.1f}"
+    bw = big_text_width(big)
+    draw_big_text(stdscr, top + 2, max(0, (w - bw) // 2), big,
+                  curses.color_pair(C_CORRECT) | curses.A_BOLD)
+    wpm_label = "words per minute" + ("   ★ new best" if is_best else "")
+    addstr_safe(stdscr, top + 8, max(0, (w - len(wpm_label)) // 2), wpm_label,
+                curses.A_BOLD if is_best else curses.A_DIM)
+
+    rows = [
+        ("Accuracy", f"{acc:.1f} %"),
+        ("Errors", f"{game.errors}"),
+        ("Time", f"{secs:.1f} s"),
+        (f"Best · {game.lang}", f"{best:.1f} wpm"),
+    ]
+    label_w = max(len(r[0]) for r in rows)
+    val_w = max(len(r[1]) for r in rows)
+    block_w = label_w + 4 + val_w
+    x = max(0, (w - block_w) // 2)
+    for i, (label, val) in enumerate(rows):
+        addstr_safe(stdscr, top + 10 + i, x, f"{label:<{label_w}}", curses.A_DIM)
+        addstr_safe(stdscr, top + 10 + i, x + label_w + 4,
+                    f"{val:>{val_w}}", curses.A_BOLD)
+
+    hint = "Enter next   Tab retry   Esc menu"
+    addstr_safe(stdscr, min(h - 1, top + 15), max(0, (w - len(hint)) // 2),
+                hint, curses.A_DIM)
+    stdscr.refresh()
+
+    while True:
+        key = stdscr.getch()
+        if key in (curses.KEY_ENTER, 10, 13):
+            return "next"
+        if key == 9:
+            return "retry"
+        if key == 27:
+            return "menu"
+
+
+def show_history(stdscr):
+    stats = load_stats()
+    runs = stats["runs"][-15:][::-1]  # newest first
+
+    stdscr.erase()
+    h, w = stdscr.getmaxyx()
+
+    title = "H I S T O R Y"
+    addstr_safe(stdscr, 1, max(0, (w - len(title)) // 2), title,
+                curses.color_pair(C_TITLE) | curses.A_BOLD)
+
+    if not runs:
+        msg = "no runs yet — go type something"
+        addstr_safe(stdscr, h // 2, max(0, (w - len(msg)) // 2), msg, curses.A_DIM)
+    else:
+        header = f"{'WHEN':<17} {'LANG':<11} {'WPM':>6} {'ACC':>7} {'TIME':>7}"
+        x = max(0, (w - len(header)) // 2)
+        addstr_safe(stdscr, 3, x, header, curses.A_BOLD | curses.A_UNDERLINE)
+        for i, r in enumerate(runs):
+            line = (f"{r['when']:<17} {r['lang']:<11} {r['wpm']:>6.1f} "
+                    f"{r['accuracy']:>6.1f}% {r['seconds']:>6.1f}s")
+            addstr_safe(stdscr, 4 + i, x, line)
+
+        bests = {}
+        for r in stats["runs"]:
+            bests[r["lang"]] = max(bests.get(r["lang"], 0.0), r["wpm"])
+        best_line = "BESTS   " + "   ".join(
+            f"{lang} {v:.1f}" for lang, v in sorted(bests.items()))
+        addstr_safe(stdscr, 5 + len(runs), max(0, (w - len(best_line)) // 2),
+                    best_line, curses.color_pair(C_CORRECT) | curses.A_BOLD)
+
+    hint = "any key to go back"
+    addstr_safe(stdscr, h - 1, max(0, (w - len(hint)) // 2), hint, curses.A_DIM)
+    stdscr.refresh()
+    stdscr.getch()
+
+
+def pick_snippet(lang, avoid=None):
+    if lang == "sentences":
+        return random_sentence_test()
+    pool = SNIPPETS[lang]
+    choices = [s for s in pool if s != avoid] or pool
+    return random.choice(choices)
+
+
+def main(stdscr):
+    curses.curs_set(0)
+    init_colors()
+    stdscr.keypad(True)
+
+    langs = sorted(SNIPPETS.keys())
+    while True:
+        options = langs + ["sentences (speed test)", "random", "history", "quit"]
+        choice = Menu(stdscr, "CODETYPE  —  offline code typing practice",
+                      options, "↑↓ move   Enter select   Esc quit",
+                      banner=banner_lines(),
+                      tagline="⌨  offline code typing practice").run()
+        if choice is None or options[choice] == "quit":
+            return
+        if options[choice] == "history":
+            show_history(stdscr)
+            continue
+        lang = options[choice].split(" ")[0]  # "sentences (speed test)" -> "sentences"
+
+        actual = random.choice(langs) if lang == "random" else lang
+        snippet = pick_snippet(actual)
+        while True:
+            game = TypingGame(stdscr, actual, snippet)
+            result = game.run()
+
+            if result == TypingGame.RESULT_MENU:
+                break
+            if result == TypingGame.RESULT_RESTART:
+                continue  # same snippet, fresh state
+
+            action = show_results(stdscr, game)
+            if action == "menu":
+                break
+            if action == "next":
+                actual = random.choice(langs) if lang == "random" else lang
+                snippet = pick_snippet(actual, avoid=snippet)
+            # "retry" keeps the same snippet
+
+
+def run():
+    curses.wrapper(main)
+
+
+if __name__ == "__main__":
+    run()

package/codetype/snippets.py

@@ -0,0 +1,158 @@
+"""Built-in code snippets for CodeType, grouped by language.
+
+Add your own: append strings to any list, or add a new language key.
+Use spaces for indentation (no tabs).
+"""
+
+import random
+
+# Word pool for the plain-text speed test ("sentences" mode).
+COMMON_WORDS = (
+    "the be to of and a in that have it for not on with he as you do at "
+    "this but his by from they we say her she or an will my one all would "
+    "there their what so up out if about who get which go me when make can "
+    "like time no just him know take people into year your good some could "
+    "them see other than then now look only come its over think also back "
+    "after use two how our work first well way even new want because any "
+    "these give day most us great where through much before right too means "
+    "old same tell does set three state never should here each while last "
+    "might still own under water long find down side been now part turn "
+    "place made live point world very still try hand high every near add "
+    "food between keep start thought help talk small end put home read "
+    "letter land change kind off need house picture again animal mother "
+    "world study learn plant cover story young life light open seem "
+    "together next white children begin got walk example paper often "
+    "always music both mark book until mile river car feet care second "
+    "group carry took rain eat room friend began idea fish mountain stop "
+    "once base hear horse cut sure watch color face wood main"
+).split()
+
+
+def random_sentence_test(word_count=30, width=52):
+    """Generate a wrapped block of random common words for a speed test."""
+    words = random.choices(COMMON_WORDS, k=word_count)
+    lines, cur = [], ""
+    for w in words:
+        if cur and len(cur) + 1 + len(w) > width:
+            lines.append(cur)
+            cur = w
+        else:
+            cur = f"{cur} {w}" if cur else w
+    lines.append(cur)
+    return "\n".join(lines)
+
+SNIPPETS = {
+    "python": [
+        'def greet(name):\n    return f"Hello, {name}!"',
+
+        'squares = [x * x for x in range(10)]\nprint(sum(squares))',
+
+        'def fib(n):\n    a, b = 0, 1\n    for _ in range(n):\n        a, b = b, a + b\n    return a',
+
+        'with open("data.txt") as f:\n    lines = [line.strip() for line in f]\n    print(len(lines))',
+
+        'class Stack:\n    def __init__(self):\n        self.items = []\n\n    def push(self, item):\n        self.items.append(item)\n\n    def pop(self):\n        return self.items.pop()',
+
+        'import json\n\ndef load_config(path):\n    try:\n        with open(path) as f:\n            return json.load(f)\n    except FileNotFoundError:\n        return {}',
+
+        'def binary_search(arr, target):\n    lo, hi = 0, len(arr) - 1\n    while lo <= hi:\n        mid = (lo + hi) // 2\n        if arr[mid] == target:\n            return mid\n        if arr[mid] < target:\n            lo = mid + 1\n        else:\n            hi = mid - 1\n    return -1',
+    ],
+
+    "javascript": [
+        'const double = (x) => x * 2;\nconsole.log([1, 2, 3].map(double));',
+
+        'function debounce(fn, ms) {\n  let timer;\n  return (...args) => {\n    clearTimeout(timer);\n    timer = setTimeout(() => fn(...args), ms);\n  };\n}',
+
+        'const users = await fetch("/api/users")\n  .then((res) => res.json())\n  .catch(() => []);',
+
+        'const unique = (arr) => [...new Set(arr)];\nconst sorted = unique([3, 1, 2, 3]).sort((a, b) => a - b);',
+
+        'class Counter {\n  #count = 0;\n\n  increment() {\n    return ++this.#count;\n  }\n\n  get value() {\n    return this.#count;\n  }\n}',
+
+        'const groupBy = (arr, key) =>\n  arr.reduce((acc, item) => {\n    (acc[item[key]] ??= []).push(item);\n    return acc;\n  }, {});',
+    ],
+
+    "c": [
+        '#include <stdio.h>\n\nint main(void) {\n    printf("Hello, world!\\n");\n    return 0;\n}',
+
+        'int max(int a, int b) {\n    return a > b ? a : b;\n}',
+
+        'void swap(int *a, int *b) {\n    int tmp = *a;\n    *a = *b;\n    *b = tmp;\n}',
+
+        'size_t my_strlen(const char *s) {\n    const char *p = s;\n    while (*p)\n        p++;\n    return (size_t)(p - s);\n}',
+
+        'int factorial(int n) {\n    int result = 1;\n    for (int i = 2; i <= n; i++) {\n        result *= i;\n    }\n    return result;\n}',
+    ],
+
+    "rust": [
+        'fn add(a: i32, b: i32) -> i32 {\n    a + b\n}',
+
+        'fn main() {\n    let nums = vec![1, 2, 3, 4];\n    let sum: i32 = nums.iter().sum();\n    println!("{}", sum);\n}',
+
+        'fn largest(list: &[i32]) -> i32 {\n    let mut largest = list[0];\n    for &item in list {\n        if item > largest {\n            largest = item;\n        }\n    }\n    largest\n}',
+
+        'struct Point {\n    x: f64,\n    y: f64,\n}\n\nimpl Point {\n    fn dist(&self) -> f64 {\n        (self.x * self.x + self.y * self.y).sqrt()\n    }\n}',
+
+        'let result = match value {\n    Some(n) if n > 0 => n * 2,\n    Some(_) => 0,\n    None => -1,\n};',
+    ],
+
+    "typescript": [
+        'interface User {\n  id: number;\n  name: string;\n  email?: string;\n}',
+
+        'function identity<T>(value: T): T {\n  return value;\n}',
+
+        'type Result<T> =\n  | { ok: true; value: T }\n  | { ok: false; error: string };',
+
+        'const pick = <T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> =>\n  Object.fromEntries(keys.map((k) => [k, obj[k]])) as Pick<T, K>;',
+
+        'async function getUser(id: number): Promise<User | null> {\n  const res = await fetch(`/api/users/${id}`);\n  if (!res.ok) return null;\n  return res.json();\n}',
+    ],
+
+    "java": [
+        'public class Main {\n    public static void main(String[] args) {\n        System.out.println("Hello, world!");\n    }\n}',
+
+        'public int max(int a, int b) {\n    return a > b ? a : b;\n}',
+
+        'List<String> names = users.stream()\n    .filter(u -> u.isActive())\n    .map(User::getName)\n    .collect(Collectors.toList());',
+
+        'public record Point(double x, double y) {\n    public double dist() {\n        return Math.sqrt(x * x + y * y);\n    }\n}',
+
+        'Map<String, Integer> counts = new HashMap<>();\nfor (String word : words) {\n    counts.merge(word, 1, Integer::sum);\n}',
+    ],
+
+    "sql": [
+        'SELECT name, email\nFROM users\nWHERE active = true\nORDER BY created_at DESC\nLIMIT 10;',
+
+        'SELECT department, COUNT(*) AS total\nFROM employees\nGROUP BY department\nHAVING COUNT(*) > 5;',
+
+        'UPDATE orders\nSET status = \'shipped\'\nWHERE id = 42;',
+
+        'SELECT u.name, o.total\nFROM users u\nJOIN orders o ON o.user_id = u.id\nWHERE o.total > 100;',
+
+        'CREATE TABLE posts (\n    id SERIAL PRIMARY KEY,\n    title TEXT NOT NULL,\n    created_at TIMESTAMP DEFAULT NOW()\n);',
+    ],
+
+    "bash": [
+        'for f in *.log; do\n    gzip "$f"\ndone',
+
+        'if [ -z "$1" ]; then\n    echo "usage: $0 <name>" >&2\n    exit 1\nfi',
+
+        'count=$(grep -c "ERROR" app.log)\necho "found $count errors"',
+
+        'while read -r line; do\n    echo "line: $line"\ndone < input.txt',
+
+        'backup() {\n    local src="$1"\n    tar -czf "${src}.tar.gz" "$src"\n}',
+    ],
+
+    "go": [
+        'func add(a, b int) int {\n    return a + b\n}',
+
+        'package main\n\nimport "fmt"\n\nfunc main() {\n    fmt.Println("Hello, world!")\n}',
+
+        'func sum(nums []int) int {\n    total := 0\n    for _, n := range nums {\n        total += n\n    }\n    return total\n}',
+
+        'func contains(items []string, target string) bool {\n    for _, item := range items {\n        if item == target {\n            return true\n        }\n    }\n    return false\n}',
+
+        'type Point struct {\n    X, Y float64\n}\n\nfunc (p Point) Dist() float64 {\n    return math.Sqrt(p.X*p.X + p.Y*p.Y)\n}',
+    ],
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "codetype",
+  "version": "1.0.0",
+  "description": "Offline terminal code-typing practice game (Python-powered)",
+  "license": "MIT",
+  "bin": {
+    "codetype": "bin/codetype.js"
+  },
+  "files": [
+    "bin/",
+    "codetype/**/*.py",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "keywords": [
+    "typing",
+    "typing-practice",
+    "cli",
+    "terminal",
+    "game",
+    "wpm",
+    "code"
+  ]
+}