qwerty-cli 0.0.1-alpha.0

package/dist/cli.js

@@ -0,0 +1,1558 @@
+// src/cli.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/config.ts
+import { Command } from "commander";
+import chalk from "chalk";
+
+// src/infra/config-store.ts
+import { z } from "zod";
+
+// src/infra/paths.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { mkdir } from "fs/promises";
+import { fileURLToPath } from "url";
+var ROOT = join(homedir(), ".qwerty-cli");
+var paths = {
+  root: ROOT,
+  config: join(ROOT, "config.json"),
+  registry: join(ROOT, "registry.json"),
+  dictsDir: join(ROOT, "dicts"),
+  dictFile: (id) => join(ROOT, "dicts", `${id}.json`),
+  dictMeta: (id) => join(ROOT, "dicts", `${id}.meta.json`),
+  stats: join(ROOT, "stats.jsonl"),
+  mistakes: join(ROOT, "mistakes.json"),
+  audioCacheDir: join(ROOT, "cache", "audio"),
+  audioCache: (word, accent) => join(ROOT, "cache", "audio", `${encodeURIComponent(word.toLowerCase())}-${accent}.mp3`)
+};
+async function ensureDirs() {
+  await mkdir(paths.dictsDir, { recursive: true });
+  await mkdir(paths.audioCacheDir, { recursive: true });
+}
+function packageAssetsDir() {
+  const here = fileURLToPath(import.meta.url);
+  return resolve(here, "..", "..", "assets");
+}
+
+// src/infra/fs-store.ts
+import { mkdir as mkdir2, readFile, rename, writeFile, appendFile, access } from "fs/promises";
+import { dirname } from "path";
+import { randomBytes } from "crypto";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(path) {
+  try {
+    const buf = await readFile(path, "utf8");
+    return JSON.parse(buf);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function writeJsonAtomic(path, value) {
+  await mkdir2(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  await writeFile(tmp, JSON.stringify(value, null, 2), "utf8");
+  await rename(tmp, path);
+}
+async function appendJsonl(path, line) {
+  await mkdir2(dirname(path), { recursive: true });
+  await appendFile(path, JSON.stringify(line) + "\n", "utf8");
+}
+async function readJsonl(path) {
+  try {
+    const buf = await readFile(path, "utf8");
+    return buf.split("\n").filter((l) => l.trim().length > 0).map((l) => JSON.parse(l));
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+
+// src/infra/config-store.ts
+var ConfigSchema = z.object({
+  mirror: z.enum(["jsdelivr", "github"]).default("jsdelivr"),
+  accent: z.enum(["us", "uk"]).default("us"),
+  chapterSize: z.number().int().positive().max(200).default(20),
+  sounds: z.object({
+    master: z.boolean().default(true),
+    keystroke: z.boolean().default(true),
+    feedback: z.boolean().default(true),
+    keySoundName: z.string().default("default")
+  }).default({ master: true, keystroke: true, feedback: true, keySoundName: "default" }),
+  autoplayPronunciation: z.boolean().default(true),
+  defaultMode: z.enum(["order", "dictation", "review", "random", "loop"]).default("order"),
+  defaultDict: z.string().optional()
+});
+var DEFAULTS = ConfigSchema.parse({});
+async function loadConfig() {
+  const raw = await readJson(paths.config);
+  if (!raw) return DEFAULTS;
+  const result = ConfigSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(`Invalid config at ${paths.config}: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function saveConfig(cfg) {
+  await writeJsonAtomic(paths.config, cfg);
+}
+function getByPath(cfg, path) {
+  const parts = path.split(".");
+  let cur = cfg;
+  for (const p of parts) {
+    if (cur === null || typeof cur !== "object") return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function setByPath(cfg, path, rawValue) {
+  const parts = path.split(".");
+  if (parts.length === 0) throw new Error("Empty config key");
+  const clone = JSON.parse(JSON.stringify(cfg));
+  let cur = clone;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const k = parts[i];
+    const next = cur[k];
+    if (typeof next !== "object" || next === null) {
+      throw new Error(`Cannot set ${path}: ${parts.slice(0, i + 1).join(".")} is not an object`);
+    }
+    cur = next;
+  }
+  const leaf = parts[parts.length - 1];
+  cur[leaf] = coerce(rawValue);
+  const validated = ConfigSchema.safeParse(clone);
+  if (!validated.success) {
+    throw new Error(`Invalid value for ${path}: ${validated.error.issues[0]?.message ?? "unknown"}`);
+  }
+  return validated.data;
+}
+function coerce(v) {
+  if (v === "true") return true;
+  if (v === "false") return false;
+  if (v === "null") return null;
+  if (/^-?\d+$/.test(v)) return Number(v);
+  if (/^-?\d+\.\d+$/.test(v)) return Number(v);
+  return v;
+}
+
+// src/commands/config.ts
+function buildConfigCommand() {
+  const cmd = new Command("config").description("Manage CLI configuration");
+  cmd.command("list").description("Show the effective merged config").action(async () => {
+    const cfg = await loadConfig();
+    console.log(JSON.stringify(cfg, null, 2));
+  });
+  cmd.command("get <key>").description("Get a config value by dotted path (e.g. sounds.keystroke)").action(async (key) => {
+    const cfg = await loadConfig();
+    const v = getByPath(cfg, key);
+    if (v === void 0) {
+      console.error(chalk.red(`Key not found: ${key}`));
+      process.exitCode = 1;
+      return;
+    }
+    console.log(typeof v === "string" ? v : JSON.stringify(v));
+  });
+  cmd.command("set <key> <value>").description("Set a config value by dotted path").action(async (key, value) => {
+    const cfg = await loadConfig();
+    const next = setByPath(cfg, key, value);
+    await saveConfig(next);
+    console.log(chalk.green(`Set ${key} = ${value}`));
+  });
+  return cmd;
+}
+
+// src/commands/dict.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+
+// src/domain/dictionary.ts
+import { z as z2 } from "zod";
+var DictionaryEntrySchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  description: z2.string().default(""),
+  category: z2.string().default(""),
+  tags: z2.array(z2.string()).default([]),
+  url: z2.string(),
+  length: z2.number().int().nonnegative().default(0),
+  language: z2.string().default("en"),
+  languageCategory: z2.string().default("en"),
+  defaultPronIndex: z2.number().int().optional()
+});
+var RegistrySchema = z2.array(DictionaryEntrySchema);
+var WordSchema = z2.object({
+  name: z2.string(),
+  trans: z2.array(z2.string()).default([]),
+  usphone: z2.string().optional(),
+  ukphone: z2.string().optional(),
+  notation: z2.string().optional()
+}).passthrough();
+var WordArraySchema = z2.array(WordSchema);
+function filterRegistry(registry, query, opts = {}) {
+  const q = query.trim().toLowerCase();
+  return registry.filter((d) => {
+    if (opts.category && d.category !== opts.category) return false;
+    if (opts.language && d.language !== opts.language) return false;
+    if (!q) return true;
+    return d.id.toLowerCase().includes(q) || d.name.toLowerCase().includes(q) || d.description.toLowerCase().includes(q) || d.category.toLowerCase().includes(q) || d.tags.some((t) => t.toLowerCase().includes(q));
+  });
+}
+
+// src/infra/registry-store.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+var cached = null;
+async function loadRegistry() {
+  if (cached) return cached;
+  const userOverride = await readJson(paths.registry);
+  if (userOverride) {
+    const parsed2 = RegistrySchema.safeParse(userOverride);
+    if (parsed2.success) {
+      cached = parsed2.data;
+      return cached;
+    }
+    console.warn(`Ignoring corrupt user registry at ${paths.registry}: ${parsed2.error.message}`);
+  }
+  const bundled = await readFile2(join2(packageAssetsDir(), "registry.snapshot.json"), "utf8");
+  const parsed = RegistrySchema.parse(JSON.parse(bundled));
+  cached = parsed;
+  return cached;
+}
+async function findEntry(id) {
+  const reg = await loadRegistry();
+  return reg.find((d) => d.id === id);
+}
+
+// src/infra/dict-downloader.ts
+import { createHash } from "crypto";
+import { stat, copyFile } from "fs/promises";
+import { request } from "undici";
+var JSDELIVR_BASE = "https://cdn.jsdelivr.net/gh/RealKai42/qwerty-learner@master";
+var GITHUB_RAW_BASE = "https://raw.githubusercontent.com/RealKai42/qwerty-learner/master";
+async function fetchWithRetry(url, retries = 2) {
+  let lastErr;
+  for (let i = 0; i <= retries; i++) {
+    try {
+      const res = await request(url, { headersTimeout: 1e4, bodyTimeout: 3e4 });
+      if (res.statusCode >= 400) throw new Error(`HTTP ${res.statusCode}`);
+      return await res.body.text();
+    } catch (err) {
+      lastErr = err;
+      if (i < retries) await new Promise((r) => setTimeout(r, 500 * (i + 1)));
+    }
+  }
+  throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
+function buildUrls(mirror, relUrl) {
+  const path = relUrl.startsWith("/") ? relUrl : `/${relUrl}`;
+  const repoPath = `/public${path}`;
+  const jsd = `${JSDELIVR_BASE}${repoPath}`;
+  const gh = `${GITHUB_RAW_BASE}${repoPath}`;
+  return mirror === "jsdelivr" ? [jsd, gh] : [gh, jsd];
+}
+async function pullDictionary(id) {
+  const entry = await findEntry(id);
+  if (!entry) throw new Error(`Unknown dictionary id: ${id}`);
+  const cfg = await loadConfig();
+  await ensureDirs();
+  const urls = buildUrls(cfg.mirror, entry.url);
+  let body = null;
+  let lastErr;
+  for (const u of urls) {
+    try {
+      body = await fetchWithRetry(u);
+      break;
+    } catch (err) {
+      lastErr = err;
+    }
+  }
+  if (!body) {
+    throw new Error(
+      `Failed to download dictionary ${id} from any mirror: ${lastErr instanceof Error ? lastErr.message : lastErr}`
+    );
+  }
+  let json;
+  try {
+    json = JSON.parse(body);
+  } catch (err) {
+    throw new Error(`Dictionary ${id} is not valid JSON: ${err.message}`);
+  }
+  const parsed = WordArraySchema.safeParse(json);
+  if (!parsed.success) {
+    throw new Error(`Dictionary ${id} failed schema validation: ${parsed.error.issues[0]?.message}`);
+  }
+  const sha = createHash("sha256").update(body).digest("hex");
+  await writeJsonAtomic(paths.dictFile(id), parsed.data);
+  const meta = { sha256: sha, size: body.length, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), id };
+  await writeJsonAtomic(paths.dictMeta(id), meta);
+  return { words: parsed.data, size: body.length };
+}
+async function importDictionary(file, id) {
+  if (!/^[a-z0-9-]+$/.test(id)) {
+    throw new Error(`Invalid id "${id}". Must match /^[a-z0-9-]+$/`);
+  }
+  await ensureDirs();
+  if (!await exists(file)) throw new Error(`File not found: ${file}`);
+  const raw = await readJson(file);
+  const parsed = WordArraySchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(`Import rejected: ${parsed.error.issues[0]?.message}`);
+  }
+  await copyFile(file, paths.dictFile(id));
+  const size = (await stat(paths.dictFile(id))).size;
+  const sha = createHash("sha256").update(JSON.stringify(parsed.data)).digest("hex");
+  const meta = { sha256: sha, size, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), id };
+  await writeJsonAtomic(paths.dictMeta(id), meta);
+  return { words: parsed.data, size };
+}
+async function loadLocalDictionary(id) {
+  const data = await readJson(paths.dictFile(id));
+  if (!data) return null;
+  const parsed = WordArraySchema.safeParse(data);
+  if (!parsed.success) throw new Error(`Local dictionary ${id} corrupt: ${parsed.error.message}`);
+  return parsed.data;
+}
+async function isLocallyAvailable(id) {
+  return exists(paths.dictFile(id));
+}
+async function ensureDictionary(id) {
+  const local = await loadLocalDictionary(id);
+  if (local) return local;
+  const { words } = await pullDictionary(id);
+  return words;
+}
+async function removeDictionary(id) {
+  const { unlink } = await import("fs/promises");
+  let removed = false;
+  for (const p of [paths.dictFile(id), paths.dictMeta(id)]) {
+    try {
+      await unlink(p);
+      removed = true;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  return removed;
+}
+
+// src/commands/dict.ts
+function fmtBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(2)} MB`;
+}
+async function renderTable(entries) {
+  const flagged = await Promise.all(
+    entries.map(async (e) => ({ entry: e, local: await isLocallyAvailable(e.id) }))
+  );
+  const widths = {
+    local: 3,
+    id: Math.max(2, ...flagged.map((f) => f.entry.id.length)),
+    name: Math.max(4, ...flagged.map((f) => f.entry.name.length)),
+    category: Math.max(8, ...flagged.map((f) => f.entry.category.length)),
+    length: Math.max(5, ...flagged.map((f) => String(f.entry.length).length))
+  };
+  const pad = (s, n) => s + " ".repeat(Math.max(0, n - visibleWidth(s)));
+  const header = [
+    pad(" ", widths.local),
+    chalk2.bold(pad("ID", widths.id)),
+    chalk2.bold(pad("Name", widths.name)),
+    chalk2.bold(pad("Category", widths.category)),
+    chalk2.bold(pad("Words", widths.length)),
+    chalk2.bold("Description")
+  ].join("  ");
+  console.log(header);
+  for (const { entry, local } of flagged) {
+    const mark = local ? chalk2.green("  \u2713") : "   ";
+    console.log(
+      [
+        pad(mark, widths.local),
+        pad(entry.id, widths.id),
+        pad(entry.name, widths.name),
+        chalk2.dim(pad(entry.category, widths.category)),
+        pad(String(entry.length), widths.length),
+        chalk2.dim(entry.description)
+      ].join("  ")
+    );
+  }
+}
+function visibleWidth(s) {
+  let w = 0;
+  const plain = s.replace(/\x1b\[[0-9;]*m/g, "");
+  for (const ch of plain) {
+    const code = ch.codePointAt(0);
+    w += code > 11904 && code < 64256 ? 2 : 1;
+  }
+  return w;
+}
+function buildDictCommand() {
+  const cmd = new Command2("dict").description("Manage dictionaries");
+  cmd.command("list").description("List dictionaries (\u2713 = locally available)").option("-c, --category <category>", "filter by category").option("--local-only", "show only locally downloaded dictionaries").action(async (opts) => {
+    const reg = await loadRegistry();
+    let entries = opts.category ? reg.filter((e) => e.category === opts.category) : reg;
+    if (opts.localOnly) {
+      const flags = await Promise.all(entries.map((e) => isLocallyAvailable(e.id)));
+      entries = entries.filter((_, i) => flags[i]);
+    }
+    await renderTable(entries);
+    console.log(chalk2.dim(`
+${entries.length} dictionaries`));
+  });
+  cmd.command("search <keyword>").description("Search the upstream registry by name/description/category/tags").option("-c, --category <category>", "restrict to category").option("-l, --language <language>", "restrict to language").action(async (keyword, opts) => {
+    const reg = await loadRegistry();
+    const matches = filterRegistry(reg, keyword, opts);
+    if (matches.length === 0) {
+      console.log(chalk2.yellow(`No dictionaries matched "${keyword}"`));
+      return;
+    }
+    await renderTable(matches);
+    console.log(chalk2.dim(`
+${matches.length} matches`));
+  });
+  cmd.command("pull <id>").description("Download an upstream dictionary into the local cache").action(async (id) => {
+    try {
+      const { words, size } = await pullDictionary(id);
+      console.log(chalk2.green(`Saved ${words.length} words (${fmtBytes(size)}) \u2192 dict ${chalk2.bold(id)}`));
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("import <file>").description("Import a local qwerty-native JSON dictionary").requiredOption("--id <id>", "dictionary id (lowercase, digits, dashes)").action(async (file, opts) => {
+    try {
+      const { words, size } = await importDictionary(file, opts.id);
+      console.log(chalk2.green(`Imported ${words.length} words (${fmtBytes(size)}) as ${chalk2.bold(opts.id)}`));
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("rm <id>").description("Remove a local dictionary").action(async (id) => {
+    const removed = await removeDictionary(id);
+    if (removed) console.log(chalk2.green(`Removed ${id}`));
+    else console.log(chalk2.yellow(`Nothing to remove for ${id}`));
+  });
+  return cmd;
+}
+
+// src/commands/practice.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import { render } from "ink";
+import { createElement } from "react";
+
+// src/util/shuffle.ts
+function shuffle(arr, rng = Math.random) {
+  const out = [...arr];
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    const tmp = out[i];
+    out[i] = out[j];
+    out[j] = tmp;
+  }
+  return out;
+}
+function mulberry32(seed) {
+  let t = seed >>> 0;
+  return () => {
+    t = t + 1831565813 >>> 0;
+    let r = Math.imul(t ^ t >>> 15, 1 | t);
+    r = r + Math.imul(r ^ r >>> 7, 61 | r) ^ r;
+    return ((r ^ r >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// src/domain/chapters.ts
+function chunkChapters(words, chapterSize) {
+  if (chapterSize <= 0) throw new Error("chapterSize must be positive");
+  const chunks = [];
+  for (let i = 0; i < words.length; i += chapterSize) {
+    chunks.push(words.slice(i, i + chapterSize));
+  }
+  return chunks;
+}
+function chapterCount(totalWords, chapterSize) {
+  return Math.ceil(totalWords / chapterSize);
+}
+function buildPlaylist(chapter, mode, seed) {
+  if (mode === "random") {
+    const rng = seed === void 0 ? Math.random : mulberry32(seed);
+    return shuffle(chapter, rng);
+  }
+  return chapter;
+}
+
+// src/domain/stats.ts
+import { z as z3 } from "zod";
+var SessionRecordSchema = z3.object({
+  ts: z3.string(),
+  dictId: z3.string(),
+  chapter: z3.number().int().nonnegative(),
+  mode: z3.string(),
+  wordCount: z3.number().int().nonnegative(),
+  errors: z3.number().int().nonnegative(),
+  durationMs: z3.number().int().nonnegative(),
+  perWordErrors: z3.record(z3.string(), z3.number().int().nonnegative()).default({})
+});
+async function appendSession(record) {
+  await appendJsonl(paths.stats, record);
+}
+async function loadSessions() {
+  const rows = await readJsonl(paths.stats);
+  return rows.map((r) => SessionRecordSchema.safeParse(r)).filter((r) => r.success).map((r) => r.data);
+}
+function computeWPM(record) {
+  if (record.durationMs === 0) return 0;
+  const minutes = record.durationMs / 6e4;
+  return Math.round(record.wordCount / minutes * 10) / 10;
+}
+function accuracy(record) {
+  if (record.wordCount === 0) return 1;
+  const wordsWithErrors = Object.keys(record.perWordErrors).length;
+  return Math.max(0, Math.min(1, (record.wordCount - wordsWithErrors) / record.wordCount));
+}
+function dailyStreak(sessions, now = /* @__PURE__ */ new Date()) {
+  if (sessions.length === 0) return 0;
+  const days = /* @__PURE__ */ new Set();
+  for (const s of sessions) days.add(s.ts.slice(0, 10));
+  let streak = 0;
+  const cur = new Date(now);
+  while (true) {
+    const key = cur.toISOString().slice(0, 10);
+    if (!days.has(key)) break;
+    streak++;
+    cur.setUTCDate(cur.getUTCDate() - 1);
+  }
+  return streak;
+}
+var SPARK = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+function sparkline(values) {
+  if (values.length === 0) return "";
+  const max = Math.max(...values, 1);
+  const min = Math.min(...values, 0);
+  const range = Math.max(1, max - min);
+  return values.map((v) => {
+    const idx = Math.floor((v - min) / range * (SPARK.length - 1));
+    return SPARK[Math.max(0, Math.min(SPARK.length - 1, idx))];
+  }).join("");
+}
+function dailyBuckets(sessions, days, now = /* @__PURE__ */ new Date()) {
+  const out = [];
+  const byDay = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const key = s.ts.slice(0, 10);
+    const arr = byDay.get(key) ?? [];
+    arr.push(s);
+    byDay.set(key, arr);
+  }
+  const cur = new Date(now);
+  cur.setUTCDate(cur.getUTCDate() - (days - 1));
+  for (let i = 0; i < days; i++) {
+    const key = cur.toISOString().slice(0, 10);
+    const todays = byDay.get(key) ?? [];
+    if (todays.length === 0) {
+      out.push({ date: key, wpm: 0, accuracy: 0, sessions: 0 });
+    } else {
+      const wpm = todays.reduce((a, s) => a + computeWPM(s), 0) / todays.length;
+      const acc = todays.reduce((a, s) => a + accuracy(s), 0) / todays.length;
+      out.push({ date: key, wpm, accuracy: acc, sessions: todays.length });
+    }
+    cur.setUTCDate(cur.getUTCDate() + 1);
+  }
+  return out;
+}
+
+// src/domain/mistakes.ts
+import { z as z4 } from "zod";
+var MistakeBookSchema = z4.record(
+  z4.string(),
+  z4.object({
+    count: z4.number().int().nonnegative(),
+    lastSeen: z4.string(),
+    dictIds: z4.array(z4.string()).default([])
+  })
+);
+async function loadMistakes() {
+  const raw = await readJson(paths.mistakes);
+  if (!raw) return {};
+  const parsed = MistakeBookSchema.safeParse(raw);
+  if (!parsed.success) {
+    console.warn("Mistake book is corrupt; starting fresh");
+    return {};
+  }
+  return parsed.data;
+}
+async function saveMistakes(book) {
+  await writeJsonAtomic(paths.mistakes, book);
+}
+function bump(book, word, dictId, delta = 1) {
+  const prev = book[word] ?? { count: 0, lastSeen: (/* @__PURE__ */ new Date(0)).toISOString(), dictIds: [] };
+  const dictIds = prev.dictIds.includes(dictId) ? prev.dictIds : [...prev.dictIds, dictId];
+  return {
+    ...book,
+    [word]: {
+      count: prev.count + delta,
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+      dictIds
+    }
+  };
+}
+function topN(book, n) {
+  return Object.entries(book).sort((a, b) => b[1].count - a[1].count).slice(0, n);
+}
+
+// src/ui/screens/PracticeScreen.tsx
+import { useState as useState2, useEffect as useEffect3, useRef as useRef3 } from "react";
+import { Box as Box4, Text as Text5, useApp as useApp2, useInput as useInput2 } from "ink";
+
+// src/ui/hooks/useWordLoop.ts
+import { useEffect, useReducer, useRef, useState } from "react";
+import { useInput, useApp } from "ink";
+
+// src/domain/input-buffer.ts
+function initialState(target) {
+  return { target, typed: "", errorsThisWord: 0 };
+}
+function reduce(state, ev) {
+  switch (ev.type) {
+    case "reset":
+      return { state: { ...state, typed: "" }, effect: "none" };
+    case "backspace": {
+      if (state.typed.length === 0) return { state, effect: "none" };
+      return { state: { ...state, typed: state.typed.slice(0, -1) }, effect: "none" };
+    }
+    case "char": {
+      const candidate = state.typed + ev.ch;
+      const targetUpToCandidate = [...state.target].slice(0, [...candidate].length).join("");
+      if (candidate === targetUpToCandidate) {
+        if (candidate.length === state.target.length) {
+          return { state: { ...state, typed: candidate }, effect: "correct" };
+        }
+        return { state: { ...state, typed: candidate }, effect: "progress" };
+      }
+      return {
+        state: { ...state, typed: "", errorsThisWord: state.errorsThisWord + 1 },
+        effect: "wrong"
+      };
+    }
+  }
+}
+
+// src/domain/session.ts
+function startSession(playlist, now = Date.now()) {
+  if (playlist.length === 0) {
+    return { startedAt: now, results: [], current: null, finishedAt: now, playlist };
+  }
+  return {
+    startedAt: now,
+    results: [],
+    current: { wordIndex: 0, wordStartedAt: now, input: initialState(playlist[0].name) },
+    finishedAt: null,
+    playlist
+  };
+}
+function feedSession(session, ev, now = Date.now()) {
+  if (!session.current) return { session, effect: "none" };
+  const { state, effect } = reduce(session.current.input, ev);
+  if (effect === "correct") {
+    const finished = {
+      word: state.target,
+      errors: state.errorsThisWord,
+      durationMs: now - session.current.wordStartedAt
+    };
+    const nextIndex = session.current.wordIndex + 1;
+    const results = [...session.results, finished];
+    if (nextIndex >= session.playlist.length) {
+      return {
+        session: { ...session, results, current: null, finishedAt: now },
+        effect
+      };
+    }
+    return {
+      session: {
+        ...session,
+        results,
+        current: {
+          wordIndex: nextIndex,
+          wordStartedAt: now,
+          input: initialState(session.playlist[nextIndex].name)
+        }
+      },
+      effect
+    };
+  }
+  return {
+    session: {
+      ...session,
+      current: { ...session.current, input: state }
+    },
+    effect
+  };
+}
+function sessionSummary(session) {
+  const errors = session.results.reduce((a, r) => a + r.errors, 0);
+  const durationMs = (session.finishedAt ?? Date.now()) - session.startedAt;
+  const perWordErrors = {};
+  for (const r of session.results) {
+    if (r.errors > 0) perWordErrors[r.word] = (perWordErrors[r.word] ?? 0) + r.errors;
+  }
+  return { wordCount: session.results.length, errors, durationMs, perWordErrors };
+}
+
+// src/ui/hooks/useWordLoop.ts
+function reducer(state, action) {
+  if (action.type === "start") {
+    return { session: startSession(action.playlist, action.now), lastEffect: null };
+  }
+  if (action.type === "event") {
+    if (action.key.backspace || action.key.delete) {
+      const r = feedSession(state.session, { type: "backspace" }, action.now);
+      return { session: r.session, lastEffect: r.effect };
+    }
+    if (action.input.length === 0) return state;
+    let session = state.session;
+    let lastEffect = state.lastEffect;
+    for (const c of action.input) {
+      const r = feedSession(session, { type: "char", ch: c }, action.now);
+      session = r.session;
+      lastEffect = r.effect;
+      if (session.finishedAt !== null) break;
+    }
+    return { session, lastEffect };
+  }
+  return state;
+}
+function useWordLoop({ playlist, onComplete, onTab, onEscape, enabled = true }) {
+  const [state, dispatch] = useReducer(reducer, void 0, () => ({
+    session: startSession(playlist, Date.now()),
+    lastEffect: null
+  }));
+  const completedRef = useRef(false);
+  const [tick, setTick] = useState(0);
+  const { exit } = useApp();
+  useInput(
+    (input, key) => {
+      if (key.ctrl && input === "c") {
+        exit();
+        return;
+      }
+      if (key.escape) {
+        onEscape?.();
+        return;
+      }
+      if (key.tab) {
+        onTab?.();
+        return;
+      }
+      if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.return) return;
+      if (key.ctrl || key.meta) return;
+      const cleaned = [...input].filter((c) => {
+        const code = c.codePointAt(0);
+        return code === 32 || code >= 33 && code !== 127;
+      }).join("");
+      if (cleaned.length === 0) return;
+      dispatch({ type: "event", input: cleaned, key, now: Date.now() });
+    },
+    { isActive: enabled }
+  );
+  useEffect(() => {
+    if (state.session.finishedAt !== null && !completedRef.current) {
+      completedRef.current = true;
+      onComplete(state.session);
+    }
+  }, [state.session, onComplete]);
+  useEffect(() => {
+    if (state.session.finishedAt !== null) return;
+    const id = setInterval(() => setTick((t) => t + 1), 1e3);
+    return () => clearInterval(id);
+  }, [state.session.finishedAt]);
+  return { session: state.session, lastEffect: state.lastEffect, tick };
+}
+
+// src/ui/hooks/useAudio.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+
+// src/infra/audio.ts
+import { spawn } from "child_process";
+import { mkdir as mkdir3, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { join as join3, dirname as dirname2 } from "path";
+import { request as request2 } from "undici";
+import PQueue from "p-queue";
+var CANDIDATES = [
+  { kind: "afplay", cmd: "afplay", args: (f) => [f], supports: "both" },
+  { kind: "ffplay", cmd: "ffplay", args: (f) => ["-nodisp", "-autoexit", "-loglevel", "quiet", f], supports: "both" },
+  { kind: "mpg123", cmd: "mpg123", args: (f) => ["-q", f], supports: "mp3" },
+  { kind: "paplay", cmd: "paplay", args: (f) => [f], supports: "wav" },
+  { kind: "aplay", cmd: "aplay", args: (f) => ["-q", f], supports: "wav" },
+  {
+    kind: "powershell",
+    cmd: "powershell",
+    args: (f) => ["-NoProfile", "-Command", `(New-Object Media.SoundPlayer '${f}').PlaySync();`],
+    supports: "wav"
+  }
+];
+var PRON_API = "https://dict.youdao.com/dictvoice?audio=";
+var runtime = null;
+async function isExecutable(cmd) {
+  return new Promise((resolve2) => {
+    const probe = spawn(cmd, ["--version"], { stdio: "ignore" });
+    probe.on("error", () => resolve2(false));
+    probe.on("exit", () => resolve2(true));
+    setTimeout(() => {
+      probe.kill();
+      resolve2(false);
+    }, 500);
+  });
+}
+async function detect() {
+  let wav = null;
+  let mp3 = null;
+  for (const p of CANDIDATES) {
+    if (!await isExecutable(p.cmd)) continue;
+    if (!wav && (p.supports === "wav" || p.supports === "both")) wav = p;
+    if (!mp3 && (p.supports === "mp3" || p.supports === "both")) mp3 = p;
+    if (wav && mp3) break;
+  }
+  return { wav, mp3 };
+}
+async function initAudio(disabledByConfig) {
+  if (runtime) return runtime;
+  if (disabledByConfig) {
+    runtime = {
+      disabled: true,
+      wavPlayer: null,
+      mp3Player: null,
+      warning: null,
+      keyQueue: new PQueue({ concurrency: 1 }),
+      feedbackQueue: new PQueue({ concurrency: 1 }),
+      pronQueue: new PQueue({ concurrency: 1 })
+    };
+    return runtime;
+  }
+  const { wav, mp3 } = await detect();
+  let warning = null;
+  if (!wav && !mp3) {
+    warning = "No audio player found on PATH (looked for afplay/ffplay/mpg123/paplay/aplay/powershell). Sounds disabled.";
+  } else if (!mp3) {
+    warning = "No MP3 player found; word pronunciations will be skipped.";
+  }
+  runtime = {
+    disabled: !wav && !mp3,
+    wavPlayer: wav,
+    mp3Player: mp3,
+    warning,
+    keyQueue: new PQueue({ concurrency: 2 }),
+    feedbackQueue: new PQueue({ concurrency: 1 }),
+    pronQueue: new PQueue({ concurrency: 1 })
+  };
+  return runtime;
+}
+function spawnPlay(player, file) {
+  try {
+    const child = spawn(player.cmd, player.args(file), {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function playFile(file, kind) {
+  if (!runtime || runtime.disabled) return;
+  const player = kind === "wav" ? runtime.wavPlayer : runtime.mp3Player;
+  if (!player) return;
+  spawnPlay(player, file);
+}
+function playKeystroke() {
+  if (!runtime || runtime.disabled) return;
+  if (runtime.keyQueue.size >= 2) return;
+  void runtime.keyQueue.add(async () => {
+    playFile(join3(packageAssetsDir(), "sounds", "key-default.wav"), "wav");
+    await new Promise((r) => setTimeout(r, 30));
+  });
+}
+function playCorrect() {
+  if (!runtime || runtime.disabled) return;
+  void runtime.feedbackQueue.add(async () => {
+    playFile(join3(packageAssetsDir(), "sounds", "correct.wav"), "wav");
+    await new Promise((r) => setTimeout(r, 50));
+  });
+}
+function playWrong() {
+  if (!runtime || runtime.disabled) return;
+  void runtime.feedbackQueue.add(async () => {
+    playFile(join3(packageAssetsDir(), "sounds", "wrong.wav"), "wav");
+    await new Promise((r) => setTimeout(r, 50));
+  });
+}
+async function downloadPronunciation(word, accent) {
+  const cacheFile = paths.audioCache(word, accent);
+  if (await exists(cacheFile)) return cacheFile;
+  await mkdir3(dirname2(cacheFile), { recursive: true });
+  const type = accent === "us" ? 2 : 1;
+  const url = `${PRON_API}${encodeURIComponent(word)}&type=${type}`;
+  try {
+    const res = await request2(url, { headersTimeout: 8e3, bodyTimeout: 2e4 });
+    if (res.statusCode >= 400) return null;
+    const buf = Buffer.from(await res.body.arrayBuffer());
+    if (buf.length < 1024) return null;
+    const tmp = `${cacheFile}.tmp`;
+    await writeFile2(tmp, buf);
+    await rename2(tmp, cacheFile);
+    return cacheFile;
+  } catch {
+    return null;
+  }
+}
+async function playPronunciation(word, accent) {
+  if (!runtime || runtime.disabled || !runtime.mp3Player) return;
+  await ensureDirs();
+  await runtime.pronQueue.add(async () => {
+    const file = await downloadPronunciation(word, accent);
+    if (file) playFile(file, "mp3");
+  });
+}
+async function prefetchPronunciation(word, accent) {
+  if (!runtime || runtime.disabled || !runtime.mp3Player) return;
+  await ensureDirs();
+  void runtime.pronQueue.add(async () => {
+    await downloadPronunciation(word, accent);
+  });
+}
+function audioWarning() {
+  return runtime?.warning ?? null;
+}
+
+// src/ui/hooks/useAudio.ts
+function useAudio(opts) {
+  const initedRef = useRef2(false);
+  useEffect2(() => {
+    if (initedRef.current) return;
+    initedRef.current = true;
+    initAudio(!opts.enabled).then(() => {
+      const w = audioWarning();
+      if (w) opts.onWarning?.(w);
+    }).catch(() => void 0);
+  }, [opts]);
+  return {
+    keystroke: () => opts.enabled && playKeystroke(),
+    correct: () => opts.enabled && playCorrect(),
+    wrong: () => opts.enabled && playWrong(),
+    pronounce: (word) => {
+      if (!opts.enabled) return;
+      if (opts.autoplayPronunciation) void playPronunciation(word, opts.accent);
+    },
+    prefetch: (word) => {
+      if (!opts.enabled) return;
+      void prefetchPronunciation(word, opts.accent);
+    }
+  };
+}
+
+// src/ui/components/WordInput.tsx
+import { Box, Text } from "ink";
+import { jsx } from "react/jsx-runtime";
+function WordInput({ state, hideTarget = false, flashError = false }) {
+  const target = [...state.target];
+  const typed = [...state.typed];
+  return /* @__PURE__ */ jsx(Box, { children: target.map((ch, i) => {
+    const t = typed[i];
+    if (t !== void 0) {
+      return /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: t }, i);
+    }
+    if (hideTarget) {
+      return /* @__PURE__ */ jsx(Text, { dimColor: true, children: "_" }, i);
+    }
+    return /* @__PURE__ */ jsx(Text, { dimColor: true, underline: true, color: flashError ? "red" : void 0, children: ch }, i);
+  }) });
+}
+
+// src/ui/components/Phonetic.tsx
+import { Text as Text2 } from "ink";
+import { jsxs } from "react/jsx-runtime";
+function Phonetic({ word, accent }) {
+  const phon = accent === "us" ? word.usphone : word.ukphone;
+  if (!phon) return null;
+  return /* @__PURE__ */ jsxs(Text2, { dimColor: true, children: [
+    "/",
+    phon,
+    "/"
+  ] });
+}
+
+// src/ui/components/Translation.tsx
+import { Box as Box2, Text as Text3 } from "ink";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function Translation({ word }) {
+  if (!word.trans || word.trans.length === 0) return null;
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: word.trans.map((t, i) => /* @__PURE__ */ jsx2(Text3, { color: "cyan", children: t }, i)) });
+}
+
+// src/ui/components/Progress.tsx
+import { Box as Box3, Text as Text4 } from "ink";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function Progress({ current, total, errors, elapsedMs }) {
+  const minutes = elapsedMs / 6e4;
+  const wpm = minutes > 0 ? Math.round(current / minutes) : 0;
+  const seconds = Math.floor(elapsedMs / 1e3);
+  return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs2(Text4, { children: [
+    /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: "progress " }),
+    /* @__PURE__ */ jsx3(Text4, { bold: true, children: current }),
+    /* @__PURE__ */ jsxs2(Text4, { dimColor: true, children: [
+      "/",
+      total
+    ] }),
+    /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: "  errors " }),
+    /* @__PURE__ */ jsx3(Text4, { color: errors > 0 ? "red" : "green", children: errors }),
+    /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: "  wpm " }),
+    /* @__PURE__ */ jsx3(Text4, { children: wpm }),
+    /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: "  time " }),
+    /* @__PURE__ */ jsxs2(Text4, { children: [
+      Math.floor(seconds / 60),
+      ":",
+      String(seconds % 60).padStart(2, "0")
+    ] })
+  ] }) });
+}
+
+// src/ui/screens/PracticeScreen.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function PracticeScreen(props) {
+  const [paused, setPaused] = useState2(false);
+  const [finished, setFinished] = useState2(null);
+  const [audioWarn, setAudioWarn] = useState2(null);
+  const { exit } = useApp2();
+  const audio = useAudio({
+    enabled: props.audio.master,
+    accent: props.accent,
+    autoplayPronunciation: props.audio.autoplayPronunciation,
+    onWarning: setAudioWarn
+  });
+  const lastEffectRef = useRef3(null);
+  const lastIndexRef = useRef3(-1);
+  const { session, lastEffect, tick } = useWordLoop({
+    playlist: props.playlist,
+    enabled: !paused && finished === null,
+    onComplete: (s) => {
+      setFinished(s);
+      Promise.resolve(props.onSessionComplete(sessionSummary(s))).catch((err) => {
+        console.error("Failed to persist session:", err);
+      });
+    },
+    onEscape: () => setPaused((p) => !p),
+    onTab: () => {
+      const cur = session.current ? props.playlist[session.current.wordIndex] : void 0;
+      if (cur) void audio.pronounce(cur.name);
+    }
+  });
+  useEffect3(() => {
+    if (lastEffect === null) return;
+    if (lastEffect === lastEffectRef.current) return;
+    lastEffectRef.current = lastEffect;
+    if (lastEffect === "wrong" && props.audio.feedback) audio.wrong();
+    if (lastEffect === "progress" && props.audio.keystroke) audio.keystroke();
+    if (lastEffect === "correct") {
+      if (props.audio.feedback) audio.correct();
+      if (props.audio.keystroke) audio.keystroke();
+    }
+  }, [lastEffect, audio, props.audio.feedback, props.audio.keystroke]);
+  useEffect3(() => {
+    const idx = session.current?.wordIndex ?? -1;
+    if (idx === -1) return;
+    if (idx === lastIndexRef.current) return;
+    lastIndexRef.current = idx;
+    const cur = props.playlist[idx];
+    const next = props.playlist[idx + 1];
+    if (cur && props.audio.autoplayPronunciation) audio.pronounce(cur.name);
+    if (next) audio.prefetch(next.name);
+  }, [session.current?.wordIndex, audio, props.audio.autoplayPronunciation, props.playlist]);
+  void tick;
+  useInput2(
+    (input) => {
+      if (input === "q") exit();
+      if (input === "r") setPaused(false);
+    },
+    { isActive: paused && finished === null }
+  );
+  useInput2(
+    (input) => {
+      if (input === "q") {
+        props.onQuit?.();
+        exit();
+      }
+      if (input === "n") {
+        props.onAdvanceChapter?.();
+        exit();
+      }
+      if (input === "m") {
+        props.onReviewMistakes?.();
+        exit();
+      }
+    },
+    { isActive: finished !== null }
+  );
+  if (finished) {
+    const summary = sessionSummary(finished);
+    const minutes = summary.durationMs / 6e4;
+    const wpm = minutes > 0 ? Math.round(summary.wordCount / minutes * 10) / 10 : 0;
+    const errorWords = Object.keys(summary.perWordErrors).length;
+    const acc = summary.wordCount === 0 ? 1 : Math.max(0, (summary.wordCount - errorWords) / summary.wordCount);
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingX: 1, paddingY: 1, borderStyle: "round", borderColor: "green", children: [
+      /* @__PURE__ */ jsxs3(Text5, { bold: true, color: "green", children: [
+        "Chapter complete: ",
+        props.dictId,
+        " chapter ",
+        props.chapterNumber,
+        "/",
+        props.totalChapters
+      ] }),
+      /* @__PURE__ */ jsx4(Box4, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsxs3(Text5, { children: [
+        /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "words " }),
+        /* @__PURE__ */ jsx4(Text5, { bold: true, children: summary.wordCount }),
+        /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "  errors " }),
+        /* @__PURE__ */ jsx4(Text5, { color: summary.errors > 0 ? "red" : "green", children: summary.errors }),
+        /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "  wpm " }),
+        /* @__PURE__ */ jsx4(Text5, { children: wpm }),
+        /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "  accuracy " }),
+        /* @__PURE__ */ jsxs3(Text5, { children: [
+          Math.round(acc * 1e3) / 10,
+          "%"
+        ] })
+      ] }) }),
+      /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "[n] next chapter  [m] review mistakes  [q] quit" }) })
+    ] });
+  }
+  if (paused) {
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingX: 1, borderStyle: "round", borderColor: "yellow", children: [
+      /* @__PURE__ */ jsx4(Text5, { bold: true, color: "yellow", children: "Paused" }),
+      /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "[r] resume  [q] quit" }) })
+    ] });
+  }
+  const currentWord = session.current ? props.playlist[session.current.wordIndex] : props.playlist[props.playlist.length - 1];
+  const inputState = session.current?.input ?? initialState("");
+  const elapsedMs = Date.now() - session.startedAt;
+  const completed = session.results.length;
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingX: 1, paddingY: 0, children: [
+    /* @__PURE__ */ jsxs3(Box4, { children: [
+      /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: props.dictId }),
+      /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+        " \xB7 chapter ",
+        props.chapterNumber,
+        "/",
+        props.totalChapters
+      ] }),
+      /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+        " \xB7 mode ",
+        props.mode
+      ] }),
+      /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+        " \xB7 accent ",
+        props.accent
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(WordInput, { state: inputState, hideTarget: props.mode === "dictation", flashError: lastEffect === "wrong" }) }),
+    currentWord && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Phonetic, { word: currentWord, accent: props.accent }) }),
+    currentWord && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Translation, { word: currentWord }) }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Progress, { current: completed, total: props.playlist.length, errors: inputState.errorsThisWord, elapsedMs }) }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "[Esc] pause   [Tab] replay pronunciation   [Ctrl+C] quit" }) }),
+    audioWarn && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text5, { color: "yellow", children: audioWarn }) })
+  ] });
+}
+
+// src/commands/practice.ts
+var MODES = ["order", "dictation", "review", "random", "loop"];
+function isMode(v) {
+  return MODES.includes(v);
+}
+async function runChapter(opts) {
+  let outcome = "done";
+  const onSessionComplete = async (summary) => {
+    const rec = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      dictId: opts.dictId,
+      chapter: opts.chapterIndex,
+      mode: opts.mode,
+      wordCount: summary.wordCount,
+      errors: summary.errors,
+      durationMs: summary.durationMs,
+      perWordErrors: summary.perWordErrors
+    };
+    await appendSession(rec);
+    if (Object.keys(summary.perWordErrors).length > 0) {
+      let book = await loadMistakes();
+      for (const [word, n] of Object.entries(summary.perWordErrors)) {
+        book = bump(book, word, opts.dictId, n);
+      }
+      await saveMistakes(book);
+    }
+  };
+  const { waitUntilExit } = render(
+    createElement(PracticeScreen, {
+      dictId: opts.dictId,
+      chapterNumber: opts.chapterIndex + 1,
+      totalChapters: opts.totalChapters,
+      playlist: opts.playlist,
+      mode: opts.mode,
+      accent: opts.accent,
+      audio: opts.audio,
+      onSessionComplete,
+      onAdvanceChapter: () => {
+        outcome = "next";
+      },
+      onReviewMistakes: () => {
+        outcome = "review";
+      },
+      onQuit: () => {
+        outcome = "quit";
+      }
+    })
+  );
+  await waitUntilExit();
+  return outcome;
+}
+async function runPractice(dictIdArg, options) {
+  if (!process.stdout.isTTY) {
+    console.error(chalk3.red("Practice requires an interactive TTY."));
+    process.exitCode = 1;
+    return;
+  }
+  const cfg = await loadConfig();
+  const dictId = dictIdArg ?? cfg.defaultDict;
+  if (!dictId) {
+    console.error(chalk3.red("No dictionary specified. Pass an id or set config.defaultDict."));
+    process.exitCode = 1;
+    return;
+  }
+  const mode = options.mode ?? cfg.defaultMode;
+  if (!isMode(mode)) {
+    console.error(chalk3.red(`Invalid mode "${mode}". Valid: ${MODES.join(", ")}`));
+    process.exitCode = 1;
+    return;
+  }
+  const words = await ensureDictionary(dictId);
+  const chapters = chunkChapters(words, cfg.chapterSize);
+  if (chapters.length === 0) {
+    console.error(chalk3.red(`Dictionary ${dictId} is empty.`));
+    process.exitCode = 1;
+    return;
+  }
+  let idx = Math.max(0, Math.min(chapters.length - 1, Number(options.chapter ?? 1) - 1));
+  const total = chapters.length;
+  const accent = cfg.accent;
+  const audioCfg = {
+    master: cfg.sounds.master,
+    keystroke: cfg.sounds.keystroke,
+    feedback: cfg.sounds.feedback,
+    autoplayPronunciation: cfg.autoplayPronunciation
+  };
+  if (mode === "review") {
+    const book = await loadMistakes();
+    const reviewWords = words.filter((w) => book[w.name]?.count);
+    if (reviewWords.length === 0) {
+      console.log(chalk3.yellow("Mistake book is empty for this dictionary. Practice some chapters first."));
+      return;
+    }
+    await runChapter({
+      dictId,
+      chapterIndex: 0,
+      totalChapters: 1,
+      playlist: reviewWords.slice(0, cfg.chapterSize),
+      mode,
+      accent,
+      audio: audioCfg
+    });
+    return;
+  }
+  while (idx < chapters.length) {
+    const chapter = chapters[idx];
+    const playlist = buildPlaylist(chapter, mode);
+    const result = await runChapter({
+      dictId,
+      chapterIndex: idx,
+      totalChapters: total,
+      playlist,
+      mode,
+      accent,
+      audio: audioCfg
+    });
+    if (result === "next") {
+      if (mode === "loop") continue;
+      idx++;
+    } else if (result === "review") {
+      const book = await loadMistakes();
+      const reviewWords = words.filter((w) => book[w.name]?.count).slice(0, cfg.chapterSize);
+      if (reviewWords.length === 0) {
+        console.log(chalk3.yellow("No mistakes to review."));
+        return;
+      }
+      await runChapter({
+        dictId,
+        chapterIndex: 0,
+        totalChapters: 1,
+        playlist: reviewWords,
+        mode: "order",
+        accent,
+        audio: audioCfg
+      });
+      return;
+    } else {
+      return;
+    }
+  }
+  console.log(chalk3.green(`Reached end of ${dictId} (${total} chapters). Nice work.`));
+  void chapterCount;
+}
+function buildPracticeCommand() {
+  return new Command3("practice").argument("[dictId]", "dictionary id; falls back to config.defaultDict").description("Start a typing practice session").option("-c, --chapter <n>", "chapter number (1-based)", "1").option("-m, --mode <mode>", "order | dictation | review | random | loop").action(async (dictIdArg, options) => {
+    await runPractice(dictIdArg, options);
+  });
+}
+
+// src/commands/stats.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+function buildStatsCommand() {
+  return new Command4("stats").description("Show practice history and trends").option("-d, --days <n>", "window size for trend (default 14)", "14").option("--top <n>", "how many top mistakes to show (default 10)", "10").action(async (opts) => {
+    const days = Math.max(1, Number(opts.days) || 14);
+    const topCount = Math.max(1, Number(opts.top) || 10);
+    const sessions = await loadSessions();
+    const book = await loadMistakes();
+    if (sessions.length === 0) {
+      console.log(chalk4.yellow("No practice history yet. Run `qwerty practice <dict>` to get started."));
+      return;
+    }
+    const buckets = dailyBuckets(sessions, days);
+    const streak = dailyStreak(sessions);
+    const totalWords = sessions.reduce((a, s) => a + s.wordCount, 0);
+    const totalErrors = sessions.reduce((a, s) => a + s.errors, 0);
+    const totalMs = sessions.reduce((a, s) => a + s.durationMs, 0);
+    const firstTryWords = sessions.reduce(
+      (a, s) => a + (s.wordCount - Object.keys(s.perWordErrors).length),
+      0
+    );
+    const overallWpm = totalMs > 0 ? Math.round(totalWords / (totalMs / 6e4) * 10) / 10 : 0;
+    const overallAcc = totalWords === 0 ? 1 : firstTryWords / totalWords;
+    console.log(chalk4.bold("\nLifetime"));
+    console.log(`  ${chalk4.dim("sessions")} ${sessions.length}   ${chalk4.dim("words")} ${totalWords}   ${chalk4.dim("errors")} ${totalErrors}`);
+    console.log(`  ${chalk4.dim("avg wpm")} ${overallWpm}   ${chalk4.dim("avg accuracy")} ${Math.round(overallAcc * 1e3) / 10}%   ${chalk4.dim("streak")} ${chalk4.bold(streak)}d`);
+    console.log(chalk4.bold(`
+Last ${days} days`));
+    console.log(`  ${chalk4.dim("wpm     ")} ${sparkline(buckets.map((b) => b.wpm))}   ${chalk4.dim("max")} ${Math.round(Math.max(...buckets.map((b) => b.wpm)))}`);
+    console.log(`  ${chalk4.dim("accuracy")} ${sparkline(buckets.map((b) => b.accuracy * 100))}   ${chalk4.dim("range")} ${Math.round(Math.min(...buckets.map((b) => b.accuracy * 100)))}-${Math.round(Math.max(...buckets.map((b) => b.accuracy * 100)))}%`);
+    console.log(`  ${chalk4.dim("sessions")} ${sparkline(buckets.map((b) => b.sessions))}`);
+    const recent = sessions.slice(-5).reverse();
+    console.log(chalk4.bold("\nLast 5 sessions"));
+    for (const s of recent) {
+      const wpm = computeWPM(s);
+      const acc = Math.round(accuracy(s) * 1e3) / 10;
+      console.log(
+        `  ${chalk4.dim(s.ts.replace("T", " ").slice(0, 16))}  ${chalk4.cyan(s.dictId.padEnd(14))} ch${String(s.chapter + 1).padStart(3)}  ${s.mode.padEnd(9)} ${String(s.wordCount).padStart(3)}w  ${s.errors}err  ${wpm}wpm  ${acc}%`
+      );
+    }
+    const top = topN(book, topCount);
+    if (top.length > 0) {
+      console.log(chalk4.bold(`
+Top ${top.length} mistakes`));
+      for (const [word, entry] of top) {
+        console.log(`  ${chalk4.red(String(entry.count).padStart(3))}  ${chalk4.bold(word.padEnd(20))} ${chalk4.dim(entry.dictIds.join(", "))}`);
+      }
+    } else {
+      console.log(chalk4.bold("\nTop mistakes"));
+      console.log(chalk4.dim("  none \u2014 keep going"));
+    }
+    console.log();
+  });
+}
+
+// src/commands/word.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import { readdir } from "fs/promises";
+async function listLocalDictIds() {
+  try {
+    const files = await readdir(paths.dictsDir);
+    return files.filter((f) => f.endsWith(".json") && !f.endsWith(".meta.json")).map((f) => f.replace(/\.json$/, ""));
+  } catch {
+    return [];
+  }
+}
+function buildWordCommand() {
+  return new Command5("word").argument("<keyword>").description("Look up a word across local dictionaries").option("--exact", "require exact (case-insensitive) match").action(async (keyword, opts) => {
+    const q = keyword.toLowerCase();
+    const ids = await listLocalDictIds();
+    if (ids.length === 0) {
+      console.log(chalk5.yellow("No local dictionaries. Run `qwerty dict pull <id>` first."));
+      return;
+    }
+    const hits = [];
+    for (const id of ids) {
+      const words = await loadLocalDictionary(id);
+      if (!words) continue;
+      for (const w of words) {
+        const wl = w.name.toLowerCase();
+        const match = opts.exact ? wl === q : wl.includes(q);
+        if (match) hits.push({ dictId: id, word: w });
+      }
+    }
+    if (hits.length === 0) {
+      console.log(chalk5.yellow(`No matches for "${keyword}" in ${ids.length} local dictionaries`));
+      return;
+    }
+    const byName = /* @__PURE__ */ new Map();
+    for (const h of hits) {
+      const arr = byName.get(h.word.name) ?? [];
+      arr.push(h);
+      byName.set(h.word.name, arr);
+    }
+    const book = await loadMistakes();
+    for (const [name, group] of byName) {
+      const first = group[0].word;
+      console.log();
+      console.log(chalk5.bold.white(name));
+      const us = first.usphone ? `US /${first.usphone}/` : "";
+      const uk = first.ukphone ? `UK /${first.ukphone}/` : "";
+      if (us || uk) console.log(chalk5.dim(`  ${[us, uk].filter(Boolean).join("   ")}`));
+      for (const t of first.trans ?? []) console.log(chalk5.cyan(`  \xB7 ${t}`));
+      const sources = await Promise.all(
+        group.map(async (h) => {
+          const reg = await findEntry(h.dictId);
+          return reg?.name ?? h.dictId;
+        })
+      );
+      console.log(chalk5.dim(`  in: ${sources.join(", ")}`));
+      const mistake = book[name];
+      if (mistake) {
+        console.log(chalk5.dim(`  mistakes: ${mistake.count} (last ${mistake.lastSeen.slice(0, 10)})`));
+      }
+    }
+    console.log();
+  });
+}
+
+// src/commands/menu.ts
+import { render as render2 } from "ink";
+import { createElement as createElement2 } from "react";
+import chalk6 from "chalk";
+
+// src/ui/screens/MainMenu.tsx
+import { useState as useState3 } from "react";
+import { Box as Box5, Text as Text6, useApp as useApp3, useInput as useInput3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var ITEMS = [
+  { key: "p", label: "Practice", hint: "qwerty practice <dictId>" },
+  { key: "d", label: "Dictionaries", hint: "qwerty dict list / search / pull" },
+  { key: "w", label: "Word lookup", hint: "qwerty word <keyword>" },
+  { key: "s", label: "Stats", hint: "qwerty stats" },
+  { key: "c", label: "Config", hint: "qwerty config list" },
+  { key: "q", label: "Quit", hint: "Ctrl+C also exits" }
+];
+function MainMenu({
+  defaultDict,
+  onAction
+}) {
+  const [selected, setSelected] = useState3(0);
+  const { exit } = useApp3();
+  useInput3((input, key) => {
+    if (key.upArrow) setSelected((i) => (i - 1 + ITEMS.length) % ITEMS.length);
+    if (key.downArrow) setSelected((i) => (i + 1) % ITEMS.length);
+    if (key.return) {
+      const item = ITEMS[selected];
+      if (item.key === "q") {
+        exit();
+        return;
+      }
+      if (item.key === "p") onAction("practice");
+    }
+    for (const it of ITEMS) {
+      if (input === it.key) {
+        if (it.key === "q") {
+          exit();
+          return;
+        }
+        if (it.key === "p") onAction("practice");
+      }
+    }
+  });
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsx5(Text6, { bold: true, color: "cyan", children: "qwerty-cli" }),
+    /* @__PURE__ */ jsx5(Text6, { dimColor: true, children: "typing practice for English vocabulary, in your terminal" }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, flexDirection: "column", children: ITEMS.map((it, i) => /* @__PURE__ */ jsxs4(Text6, { children: [
+      i === selected ? chalkArrow() : "  ",
+      /* @__PURE__ */ jsxs4(Text6, { bold: i === selected, color: i === selected ? "cyan" : void 0, children: [
+        "[",
+        it.key,
+        "]"
+      ] }),
+      " ",
+      /* @__PURE__ */ jsx5(Text6, { bold: i === selected, children: it.label.padEnd(14) }),
+      /* @__PURE__ */ jsx5(Text6, { dimColor: true, children: it.hint })
+    ] }, it.key)) }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
+      "default dict: ",
+      defaultDict ?? "none \u2014 set with `qwerty config set defaultDict <id>`"
+    ] }) }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text6, { dimColor: true, children: "\u2191/\u2193 navigate \xB7 Enter to select \xB7 letters jump" }) })
+  ] });
+}
+function chalkArrow() {
+  return "> ";
+}
+
+// src/commands/menu.ts
+async function runMainMenu() {
+  if (!process.stdout.isTTY) {
+    console.log("qwerty-cli \u2014 run `qwerty --help` for available commands.");
+    return;
+  }
+  const cfg = await loadConfig();
+  let chosen = null;
+  const { waitUntilExit, unmount } = render2(
+    createElement2(MainMenu, {
+      defaultDict: cfg.defaultDict,
+      onAction: (action) => {
+        chosen = action;
+        unmount();
+      }
+    })
+  );
+  await waitUntilExit();
+  if (chosen === "practice") {
+    if (cfg.defaultDict) {
+      console.log(chalk6.dim(`Tip: \`qwerty practice ${cfg.defaultDict}\` skips this menu next time.`));
+      await runPractice(cfg.defaultDict, {});
+    } else {
+      console.log(
+        chalk6.yellow(
+          "No default dictionary set. Run `qwerty dict pull <id>` then `qwerty config set defaultDict <id>`."
+        )
+      );
+    }
+  }
+}
+
+// src/cli.ts
+var program = new Command6();
+program.name("qwerty").description("Terminal clone of qwerty-learner \u2014 typing practice for English vocabulary").version("0.1.0");
+program.addCommand(buildPracticeCommand());
+program.addCommand(buildDictCommand());
+program.addCommand(buildWordCommand());
+program.addCommand(buildStatsCommand());
+program.addCommand(buildConfigCommand());
+program.action(async () => {
+  await runMainMenu();
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map