@siddhaartha_bs/monkcli 0.1.0

package/dist/monkcli.js

@@ -0,0 +1,1451 @@
+// apps/cli/src/index.tsx
+import { render } from "ink";
+
+// apps/cli/src/App.tsx
+import { Box as Box3, useApp, useInput, useStdout } from "ink";
+
+// apps/cli/src/hooks/useTypingController.ts
+import { useCallback, useEffect, useMemo, useState } from "react";
+
+// packages/engine/src/generator.ts
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomWord(words) {
+  return words[randomInt(0, words.length - 1)];
+}
+function randomDigits(length) {
+  let out = "";
+  for (let i = 0; i < length; i++) {
+    out += randomInt(0, 9).toString();
+  }
+  return out;
+}
+function capitalize(word) {
+  if (word.length === 0) return word;
+  return word[0].toUpperCase() + word.slice(1);
+}
+function addPunctuation(word, index, total, sentenceStart) {
+  let nextWord = sentenceStart ? capitalize(word) : word;
+  const isLast = index === total - 1;
+  const roll = Math.random();
+  if (isLast || roll < 0.1) {
+    nextWord += ".";
+    return { word: nextWord, sentenceStart: true };
+  }
+  if (roll < 0.3) {
+    nextWord += ",";
+    return { word: nextWord, sentenceStart: false };
+  }
+  return { word: nextWord, sentenceStart: false };
+}
+function generateWordSequence(dictionary, options) {
+  if (dictionary.length === 0) {
+    throw new Error("Dictionary is empty");
+  }
+  const count = Math.max(1, options.count);
+  const punctuation = options.punctuation ?? false;
+  const numbers = options.numbers ?? false;
+  const avoidConsecutiveRepeats = options.avoidConsecutiveRepeats ?? true;
+  const out = [];
+  let sentenceStart = true;
+  for (let i = 0; i < count; i++) {
+    let word = randomWord(dictionary).trim();
+    if (avoidConsecutiveRepeats && out.length > 0) {
+      let retries = 0;
+      while (retries < 24 && word === out[out.length - 1]?.replace(/[.,!?]$/, "")) {
+        retries++;
+        word = randomWord(dictionary).trim();
+      }
+    }
+    if (numbers && Math.random() < 0.1) {
+      word = randomDigits(4);
+    }
+    if (punctuation) {
+      const punctuated = addPunctuation(word, i, count, sentenceStart);
+      word = punctuated.word;
+      sentenceStart = punctuated.sentenceStart;
+    }
+    out.push(word);
+  }
+  return out;
+}
+
+// packages/engine/src/stats.ts
+function splitInputWords(inputText) {
+  if (inputText.length === 0) return [];
+  const words = inputText.split(" ");
+  if (words[words.length - 1] === "") words.pop();
+  return words;
+}
+function round2(value) {
+  return Math.round(value * 100) / 100;
+}
+function countChars(targetWords, inputWords, includePartialLastWordInWpm) {
+  let correctWordChars = 0;
+  let allCorrectChars = 0;
+  let incorrectChars = 0;
+  let extraChars = 0;
+  let missedChars = 0;
+  let spaces = 0;
+  let correctSpaces = 0;
+  for (let i = 0; i < inputWords.length; i++) {
+    const inputWord = inputWords[i] ?? "";
+    const targetWord = targetWords[i] ?? "";
+    if (inputWord === targetWord) {
+      correctWordChars += targetWord.length;
+      allCorrectChars += targetWord.length;
+      if (i < inputWords.length - 1) {
+        correctSpaces++;
+      }
+    } else if (inputWord.length >= targetWord.length) {
+      for (let c = 0; c < inputWord.length; c++) {
+        if (c < targetWord.length) {
+          if (inputWord[c] === targetWord[c]) {
+            allCorrectChars++;
+          } else {
+            incorrectChars++;
+          }
+        } else {
+          extraChars++;
+        }
+      }
+    } else {
+      const toAdd = { correct: 0, incorrect: 0, missed: 0 };
+      for (let c = 0; c < targetWord.length; c++) {
+        if (c < inputWord.length) {
+          if (inputWord[c] === targetWord[c]) {
+            toAdd.correct++;
+          } else {
+            toAdd.incorrect++;
+          }
+        } else {
+          toAdd.missed++;
+        }
+      }
+      allCorrectChars += toAdd.correct;
+      incorrectChars += toAdd.incorrect;
+      const isLastInputWord = i === inputWords.length - 1;
+      if (isLastInputWord && includePartialLastWordInWpm) {
+        if (toAdd.incorrect === 0) {
+          correctWordChars += toAdd.correct;
+        }
+      } else {
+        missedChars += toAdd.missed;
+      }
+    }
+    if (i < inputWords.length - 1) {
+      spaces++;
+    }
+  }
+  return {
+    spaces,
+    correctWordChars,
+    allCorrectChars,
+    incorrectChars,
+    extraChars,
+    missedChars,
+    correctSpaces
+  };
+}
+function calculateStats(input) {
+  const elapsedSeconds = Math.max(input.elapsedSeconds, 1e-3);
+  const inputWords = splitInputWords(input.inputText);
+  const chars = countChars(
+    input.targetWords,
+    inputWords,
+    input.includePartialLastWordInWpm
+  );
+  const wpm = round2(
+    (chars.correctWordChars + chars.correctSpaces) * (60 / elapsedSeconds) / 5
+  );
+  const rawWpm = round2(
+    (chars.allCorrectChars + chars.spaces + chars.incorrectChars + chars.extraChars) * (60 / elapsedSeconds) / 5
+  );
+  const accuracyFromKeystrokes = input.accuracyCounts.correct / (input.accuracyCounts.correct + input.accuracyCounts.incorrect || 1) * 100;
+  const accuracy = round2(
+    Number.isFinite(accuracyFromKeystrokes) ? accuracyFromKeystrokes : 100
+  );
+  return {
+    wpm: Number.isFinite(wpm) ? wpm : 0,
+    rawWpm: Number.isFinite(rawWpm) ? rawWpm : 0,
+    accuracy,
+    elapsedSeconds: round2(elapsedSeconds),
+    chars,
+    accuracyCounts: input.accuracyCounts
+  };
+}
+
+// packages/engine/src/session.ts
+var TypingSession = class {
+  mode;
+  durationSeconds;
+  targetWords;
+  targetText;
+  createdAt;
+  startedAt;
+  endedAt;
+  inputText = "";
+  accuracy = { correct: 0, incorrect: 0 };
+  constructor(init) {
+    this.mode = init.mode;
+    this.durationSeconds = Math.max(1, init.durationSeconds);
+    this.targetWords = init.targetWords;
+    this.targetText = this.targetWords.join(" ");
+    this.createdAt = init.startedAt ?? Date.now();
+  }
+  get input() {
+    return this.inputText;
+  }
+  get isFinished() {
+    return this.endedAt !== void 0;
+  }
+  ensureStarted(now) {
+    if (this.startedAt === void 0) {
+      this.startedAt = now;
+    }
+  }
+  applyCharacter(char, now = Date.now()) {
+    if (!char || this.isFinished) return;
+    this.ensureStarted(now);
+    const expected = this.targetText[this.inputText.length] ?? "";
+    if (char === expected) {
+      this.accuracy.correct++;
+    } else {
+      this.accuracy.incorrect++;
+    }
+    this.inputText += char;
+  }
+  backspace() {
+    if (this.isFinished) return;
+    if (this.inputText.length === 0) return;
+    this.inputText = this.inputText.slice(0, -1);
+  }
+  getElapsedSeconds(now = Date.now()) {
+    const start = this.startedAt ?? this.createdAt;
+    const end = this.endedAt ?? now;
+    return Math.max(0, (end - start) / 1e3);
+  }
+  getRemainingSeconds(now = Date.now()) {
+    if (this.mode !== "time") return 0;
+    const remaining = this.durationSeconds - this.getElapsedSeconds(now);
+    return Math.max(0, remaining);
+  }
+  hasCompletedWordTarget() {
+    if (this.mode !== "words") return false;
+    const typedWords = this.inputText.trim().length > 0 ? this.inputText.trim().split(/\s+/).length : 0;
+    const submitted = this.inputText.endsWith(" ") || this.inputText === this.targetText;
+    return submitted && typedWords >= this.targetWords.length;
+  }
+  hasTypedFinalWordCorrectly() {
+    if (this.mode !== "words") return false;
+    const typedWords = this.inputText.trim().split(/\s+/).filter((word) => word.length > 0);
+    if (typedWords.length !== this.targetWords.length) return false;
+    const typedLastWord = typedWords[typedWords.length - 1];
+    const targetLastWord = this.targetWords[this.targetWords.length - 1];
+    return typedLastWord === targetLastWord;
+  }
+  hasCompletedQuoteTarget() {
+    if (this.mode !== "quote") return false;
+    return this.inputText === this.targetText;
+  }
+  shouldAutoFinish(now = Date.now()) {
+    if (this.isFinished) return false;
+    if (this.mode === "time") {
+      if (this.startedAt === void 0) return false;
+      return this.getElapsedSeconds(now) >= this.durationSeconds;
+    }
+    if (this.mode === "words") {
+      return this.hasCompletedWordTarget() || this.hasTypedFinalWordCorrectly();
+    }
+    return this.hasCompletedQuoteTarget();
+  }
+  finish(now = Date.now()) {
+    if (this.isFinished) return;
+    this.ensureStarted(now);
+    this.endedAt = now;
+  }
+  getProgress(now = Date.now()) {
+    return calculateStats({
+      targetWords: this.targetWords,
+      inputText: this.inputText,
+      elapsedSeconds: this.getElapsedSeconds(now),
+      accuracyCounts: this.accuracy,
+      includePartialLastWordInWpm: this.mode !== "words"
+    });
+  }
+  buildResult(now = Date.now()) {
+    this.finish(now);
+    const progress = this.getProgress(now);
+    return {
+      ...progress,
+      mode: this.mode,
+      targetWords: this.targetWords,
+      targetText: this.targetText,
+      inputText: this.inputText,
+      completedAt: new Date(now).toISOString()
+    };
+  }
+};
+
+// packages/engine/src/word-source.ts
+import { existsSync, promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function normalizeLanguageDataset(raw, fallbackName) {
+  if (Array.isArray(raw)) {
+    const words = raw.filter((entry) => typeof entry === "string");
+    return {
+      name: fallbackName,
+      words,
+      orderedByFrequency: false
+    };
+  }
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    const words = Array.isArray(obj.words) ? obj.words.filter((entry) => typeof entry === "string") : [];
+    return {
+      name: typeof obj.name === "string" ? obj.name : fallbackName,
+      words,
+      orderedByFrequency: typeof obj.orderedByFrequency === "boolean" ? obj.orderedByFrequency : void 0
+    };
+  }
+  return {
+    name: fallbackName,
+    words: []
+  };
+}
+function resolveEngineDataDir(engineDataDir) {
+  const envDir = process.env.MONKCLI_ENGINE_DATA_DIR;
+  const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+  const moduleRelative = path.resolve(moduleDir, "../../../engine-data");
+  const candidates = [
+    engineDataDir,
+    envDir,
+    path.resolve(process.cwd(), "engine-data"),
+    path.resolve(process.cwd(), "../engine-data"),
+    path.resolve(process.cwd(), "../../engine-data"),
+    moduleRelative
+  ].filter((candidate) => !!candidate);
+  for (const candidate of candidates) {
+    const probe = path.join(candidate, "frontend", "static", "languages");
+    if (existsSync(probe)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    "Unable to resolve engine-data directory. Set MONKCLI_ENGINE_DATA_DIR or run from monkcli root."
+  );
+}
+async function loadLanguageDataset(language, options = {}) {
+  const engineDataDir = resolveEngineDataDir(options.engineDataDir);
+  const filePath = path.join(
+    engineDataDir,
+    "frontend",
+    "static",
+    "languages",
+    `${language}.json`
+  );
+  const raw = await fs.readFile(filePath, "utf8");
+  const parsed = normalizeLanguageDataset(JSON.parse(raw), language);
+  if (!Array.isArray(parsed.words) || parsed.words.length === 0) {
+    throw new Error(`Language dataset ${language} has no words`);
+  }
+  return parsed;
+}
+async function loadLanguageWords(language, options = {}) {
+  const dataset = await loadLanguageDataset(language, options);
+  return dataset.words;
+}
+async function listAvailableLanguages(options = {}) {
+  const engineDataDir = resolveEngineDataDir(options.engineDataDir);
+  const languagesDir = path.join(engineDataDir, "frontend", "static", "languages");
+  const entries = await fs.readdir(languagesDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.replace(/\.json$/, "")).sort();
+}
+async function loadQuoteDataset(language, options = {}) {
+  const engineDataDir = resolveEngineDataDir(options.engineDataDir);
+  const filePath = path.join(
+    engineDataDir,
+    "frontend",
+    "static",
+    "quotes",
+    `${language}.json`
+  );
+  const raw = await fs.readFile(filePath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed.quotes) || parsed.quotes.length === 0) {
+    throw new Error(`Quote dataset ${language} has no quotes`);
+  }
+  return parsed;
+}
+async function loadQuoteTexts(language, options = {}) {
+  const dataset = await loadQuoteDataset(language, options);
+  return dataset.quotes.map((quote) => quote.text).filter((text) => typeof text === "string" && text.trim().length > 0);
+}
+
+// packages/storage-local/src/index.ts
+import { existsSync as existsSync2, promises as fs2 } from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+var CURRENT_VERSION = 1;
+var APP_NAME = "monkcli";
+var EMPTY_STATS = {
+  totalTests: 0,
+  sumWpm: 0,
+  sumAccuracy: 0,
+  averageWpm: 0,
+  averageAccuracy: 0
+};
+function resolveConfigDir() {
+  if (process.env.MONKCLI_CONFIG_DIR) {
+    return process.env.MONKCLI_CONFIG_DIR;
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path2.join(os.homedir(), "AppData", "Roaming");
+    return path2.join(appData, APP_NAME);
+  }
+  if (process.platform === "darwin") {
+    return path2.join(os.homedir(), "Library", "Application Support", APP_NAME);
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? path2.join(os.homedir(), ".config");
+  return path2.join(xdgConfig, APP_NAME);
+}
+function resolveDataDir() {
+  if (process.env.MONKCLI_DATA_DIR) {
+    return process.env.MONKCLI_DATA_DIR;
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA ?? path2.join(os.homedir(), "AppData", "Local");
+    return path2.join(localAppData, APP_NAME);
+  }
+  if (process.platform === "darwin") {
+    return path2.join(os.homedir(), "Library", "Application Support", APP_NAME);
+  }
+  const xdgState = process.env.XDG_STATE_HOME ?? path2.join(os.homedir(), ".local", "state");
+  return path2.join(xdgState, APP_NAME);
+}
+function resolveLegacyDir() {
+  return path2.join(os.homedir(), ".monkcli");
+}
+function resolveResultsFilePath(customPath) {
+  if (customPath) return customPath;
+  return path2.join(resolveDataDir(), "results.json");
+}
+function resolveStatsFilePath(customPath) {
+  if (customPath) return customPath;
+  return path2.join(resolveDataDir(), "stats.json");
+}
+function resolveSettingsFilePath(customPath) {
+  if (customPath) return customPath;
+  return path2.join(resolveConfigDir(), "settings.json");
+}
+function resolveLegacyResultsFilePath() {
+  return path2.join(resolveLegacyDir(), "results.json");
+}
+function resolveLegacySettingsFilePath() {
+  return path2.join(resolveLegacyDir(), "settings.json");
+}
+async function ensureParent(filePath) {
+  await fs2.mkdir(path2.dirname(filePath), { recursive: true });
+}
+function mergeSettings(defaultSettings, stored) {
+  if (!stored || typeof stored !== "object") return defaultSettings;
+  const maybeSettings = stored.settings;
+  if (!maybeSettings || typeof maybeSettings !== "object") return defaultSettings;
+  return {
+    language: maybeSettings.language ?? defaultSettings.language,
+    mode: maybeSettings.mode ?? defaultSettings.mode,
+    wordTarget: maybeSettings.wordTarget ?? defaultSettings.wordTarget,
+    timeTargetSeconds: maybeSettings.timeTargetSeconds ?? defaultSettings.timeTargetSeconds
+  };
+}
+function normalizeStats(raw) {
+  if (!raw || typeof raw !== "object") return EMPTY_STATS;
+  const candidate = raw;
+  const totalTests = Number.isFinite(candidate.totalTests) ? Math.max(0, Number(candidate.totalTests)) : 0;
+  const sumWpm = Number.isFinite(candidate.sumWpm) ? Math.max(0, Number(candidate.sumWpm)) : 0;
+  const sumAccuracy = Number.isFinite(candidate.sumAccuracy) ? Math.max(0, Number(candidate.sumAccuracy)) : 0;
+  if (totalTests === 0) return EMPTY_STATS;
+  const averageWpm = sumWpm / totalTests;
+  const averageAccuracy = sumAccuracy / totalTests;
+  return {
+    totalTests,
+    sumWpm,
+    sumAccuracy,
+    averageWpm,
+    averageAccuracy
+  };
+}
+function calculateStatsFromHistory(history) {
+  if (history.length === 0) return EMPTY_STATS;
+  let sumWpm = 0;
+  let sumAccuracy = 0;
+  for (const result of history) {
+    sumWpm += result.wpm;
+    sumAccuracy += result.accuracy;
+  }
+  const totalTests = history.length;
+  return {
+    totalTests,
+    sumWpm,
+    sumAccuracy,
+    averageWpm: sumWpm / totalTests,
+    averageAccuracy: sumAccuracy / totalTests
+  };
+}
+async function writeStats(stats, customPath) {
+  const filePath = resolveStatsFilePath(customPath);
+  const payload = {
+    version: CURRENT_VERSION,
+    stats
+  };
+  await ensureParent(filePath);
+  await fs2.writeFile(filePath, JSON.stringify(payload, null, 2), "utf8");
+}
+async function readStoredResults(customPath) {
+  const filePath = resolveResultsFilePath(customPath);
+  try {
+    const raw = await fs2.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.results)) return [];
+    return parsed.results;
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT" && !customPath) {
+      const legacyPath = resolveLegacyResultsFilePath();
+      if (!existsSync2(legacyPath)) return [];
+      const rawLegacy = await fs2.readFile(legacyPath, "utf8");
+      const parsedLegacy = JSON.parse(rawLegacy);
+      return Array.isArray(parsedLegacy.results) ? parsedLegacy.results : [];
+    }
+    if (err.code === "ENOENT") return [];
+    throw error;
+  }
+}
+async function readStoredStats(customPath) {
+  const filePath = resolveStatsFilePath(customPath);
+  try {
+    const raw = await fs2.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return normalizeStats(parsed.stats);
+  } catch (error) {
+    const err = error;
+    if (err.code !== "ENOENT") {
+      throw error;
+    }
+    const history = await readStoredResults();
+    const derived = calculateStatsFromHistory(history);
+    if (derived.totalTests > 0) {
+      await writeStats(derived, customPath);
+    }
+    return derived;
+  }
+}
+async function saveResultAndUpdateStats(result, customResultsPath, customStatsPath) {
+  const filePath = resolveResultsFilePath(customResultsPath);
+  const existing = await readStoredResults(filePath);
+  const payload = {
+    version: CURRENT_VERSION,
+    results: [result, ...existing]
+  };
+  await ensureParent(filePath);
+  await fs2.writeFile(filePath, JSON.stringify(payload, null, 2), "utf8");
+  const currentStats = await readStoredStats(customStatsPath);
+  const totalTests = currentStats.totalTests + 1;
+  const sumWpm = currentStats.sumWpm + result.wpm;
+  const sumAccuracy = currentStats.sumAccuracy + result.accuracy;
+  const nextStats = {
+    totalTests,
+    sumWpm,
+    sumAccuracy,
+    averageWpm: sumWpm / totalTests,
+    averageAccuracy: sumAccuracy / totalTests
+  };
+  await writeStats(nextStats, customStatsPath);
+  return nextStats;
+}
+async function readStoredSettings(defaultSettings, customPath) {
+  const filePath = resolveSettingsFilePath(customPath);
+  try {
+    const raw = await fs2.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return mergeSettings(defaultSettings, parsed);
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT" && !customPath) {
+      const legacyPath = resolveLegacySettingsFilePath();
+      if (!existsSync2(legacyPath)) return defaultSettings;
+      const rawLegacy = await fs2.readFile(legacyPath, "utf8");
+      const parsedLegacy = JSON.parse(rawLegacy);
+      return mergeSettings(defaultSettings, parsedLegacy);
+    }
+    if (err.code === "ENOENT") {
+      return defaultSettings;
+    }
+    throw error;
+  }
+}
+async function saveSettings(settings, customPath) {
+  const filePath = resolveSettingsFilePath(customPath);
+  const payload = {
+    version: CURRENT_VERSION,
+    settings
+  };
+  await ensureParent(filePath);
+  await fs2.writeFile(filePath, JSON.stringify(payload, null, 2), "utf8");
+}
+
+// apps/cli/src/config.ts
+import path3 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var DEFAULT_LANGUAGE = "english";
+var WORD_TARGET_OPTIONS = [10, 20, 50, 100];
+var TIME_TARGET_OPTIONS = [15, 30, 60, 120];
+var TIME_MODE_WORD_POOL = 120;
+var DEFAULT_SETTINGS = {
+  language: DEFAULT_LANGUAGE,
+  mode: "time",
+  wordTarget: 10,
+  timeTargetSeconds: 30
+};
+var APP_DIR = path3.dirname(fileURLToPath2(import.meta.url));
+var ENGINE_DATA_DIR = path3.resolve(APP_DIR, "../../../engine-data");
+
+// apps/cli/src/hooks/useTypingController.ts
+var MODE_OPTIONS = ["time", "words", "quote"];
+function wrapIndex(index, total) {
+  if (total <= 0) return 0;
+  return (index % total + total) % total;
+}
+function cycleValue(values, current, delta) {
+  if (values.length === 0) return current;
+  const currentIndex = values.indexOf(current);
+  const baseIndex = currentIndex >= 0 ? currentIndex : 0;
+  return values[wrapIndex(baseIndex + delta, values.length)];
+}
+function languageRank(language) {
+  if (language === "english") return 0;
+  const match = language.match(/^english_(\d+)k$/);
+  if (!match) return Number.MAX_SAFE_INTEGER;
+  return Number(match[1]);
+}
+function getEnglishLanguageOptions(languages) {
+  const englishOnly = languages.filter(
+    (language) => language === "english" || /^english_\d+k$/.test(language)
+  );
+  const source = englishOnly.length > 0 ? englishOnly : languages;
+  return [...source].sort((a, b) => {
+    const rankDiff = languageRank(a) - languageRank(b);
+    if (Number.isFinite(rankDiff) && rankDiff !== 0) return rankDiff;
+    return a.localeCompare(b);
+  });
+}
+function normalizeSettings(stored, availableLanguages) {
+  return {
+    language: availableLanguages.includes(stored.language) ? stored.language : availableLanguages[0] ?? DEFAULT_SETTINGS.language,
+    mode: MODE_OPTIONS.includes(stored.mode) ? stored.mode : DEFAULT_SETTINGS.mode,
+    wordTarget: WORD_TARGET_OPTIONS.some((option) => option === stored.wordTarget) ? stored.wordTarget : DEFAULT_SETTINGS.wordTarget,
+    timeTargetSeconds: TIME_TARGET_OPTIONS.some((option) => option === stored.timeTargetSeconds) ? stored.timeTargetSeconds : DEFAULT_SETTINGS.timeTargetSeconds
+  };
+}
+function useTypingController() {
+  const [phase, setPhase] = useState("loading");
+  const [mode, setMode] = useState(DEFAULT_SETTINGS.mode);
+  const [menuCursor, setMenuCursor] = useState(0);
+  const [language, setLanguage] = useState(DEFAULT_SETTINGS.language);
+  const [availableLanguages, setAvailableLanguages] = useState([]);
+  const [dictionaries, setDictionaries] = useState({});
+  const [quotes, setQuotes] = useState([]);
+  const [wordTarget, setWordTarget] = useState(DEFAULT_SETTINGS.wordTarget);
+  const [timeTargetSeconds, setTimeTargetSeconds] = useState(
+    DEFAULT_SETTINGS.timeTargetSeconds
+  );
+  const [session, setSession] = useState(null);
+  const [now, setNow] = useState(Date.now());
+  const [inputVersion, setInputVersion] = useState(0);
+  const [lastResult, setLastResult] = useState(null);
+  const [historyCount, setHistoryCount] = useState(0);
+  const [averageWpm, setAverageWpm] = useState(0);
+  const [averageAccuracy, setAverageAccuracy] = useState(0);
+  const [errorMessage, setErrorMessage] = useState("");
+  const [isBootstrapped, setIsBootstrapped] = useState(false);
+  const [isFinalizing, setIsFinalizing] = useState(false);
+  const resultsFilePath = useMemo(() => resolveResultsFilePath(), []);
+  const settingsFilePath = useMemo(() => resolveSettingsFilePath(), []);
+  const statsFilePath = useMemo(() => resolveStatsFilePath(), []);
+  const menuItemCount = mode === "quote" ? 2 : 3;
+  useEffect(() => {
+    let cancelled = false;
+    const bootstrap = async () => {
+      try {
+        const [languages, stats, storedSettings, loadedQuotes] = await Promise.all([
+          listAvailableLanguages({ engineDataDir: ENGINE_DATA_DIR }),
+          readStoredStats(),
+          readStoredSettings(DEFAULT_SETTINGS),
+          loadQuoteTexts("english", { engineDataDir: ENGINE_DATA_DIR }).catch(() => [])
+        ]);
+        if (cancelled) return;
+        const languageOptions = getEnglishLanguageOptions(languages);
+        if (languageOptions.length === 0) {
+          throw new Error("No language datasets found in engine-data");
+        }
+        const dictionarySettled = await Promise.allSettled(
+          languageOptions.map(async (languageName) => {
+            const words = await loadLanguageWords(languageName, {
+              engineDataDir: ENGINE_DATA_DIR
+            });
+            return [languageName, words.map((word) => word.toLowerCase())];
+          })
+        );
+        if (cancelled) return;
+        const successfulEntries = [];
+        for (const entry of dictionarySettled) {
+          if (entry.status === "fulfilled") {
+            successfulEntries.push(entry.value);
+          }
+        }
+        const dictionaryMap = Object.fromEntries(successfulEntries);
+        const validLanguages = languageOptions.filter(
+          (languageName) => (dictionaryMap[languageName]?.length ?? 0) > 0
+        );
+        if (validLanguages.length === 0) {
+          throw new Error("No valid language datasets found in engine-data");
+        }
+        const normalized = normalizeSettings(storedSettings, validLanguages);
+        setAvailableLanguages(validLanguages);
+        setDictionaries(dictionaryMap);
+        setQuotes(loadedQuotes);
+        setLanguage(normalized.language);
+        setMode(normalized.mode);
+        setWordTarget(normalized.wordTarget);
+        setTimeTargetSeconds(normalized.timeTargetSeconds);
+        setHistoryCount(stats.totalTests);
+        setAverageWpm(stats.averageWpm);
+        setAverageAccuracy(stats.averageAccuracy);
+        setPhase("menu");
+        setIsBootstrapped(true);
+      } catch (error) {
+        if (cancelled) return;
+        setErrorMessage(error instanceof Error ? error.message : String(error));
+        setPhase("error");
+      }
+    };
+    void bootstrap();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  useEffect(() => {
+    if (!isBootstrapped) return;
+    const settings = {
+      language,
+      mode,
+      wordTarget,
+      timeTargetSeconds
+    };
+    void saveSettings(settings).catch(() => void 0);
+  }, [isBootstrapped, language, mode, wordTarget, timeTargetSeconds]);
+  useEffect(() => {
+    setMenuCursor((prev) => Math.min(prev, menuItemCount - 1));
+  }, [menuItemCount]);
+  const moveMenuCursor = useCallback(
+    (delta) => {
+      setMenuCursor((prev) => wrapIndex(prev + delta, menuItemCount));
+    },
+    [menuItemCount]
+  );
+  const adjustFocusedSetting = useCallback(
+    (delta) => {
+      if (menuCursor === 0) {
+        setLanguage((prev) => cycleValue(availableLanguages, prev, delta));
+        return;
+      }
+      if (menuCursor === 1) {
+        setMode((prev) => cycleValue(MODE_OPTIONS, prev, delta));
+        return;
+      }
+      if (menuCursor === 2 && mode === "time") {
+        setTimeTargetSeconds((prev) => cycleValue(TIME_TARGET_OPTIONS, prev, delta));
+      }
+      if (menuCursor === 2 && mode === "words") {
+        setWordTarget((prev) => cycleValue(WORD_TARGET_OPTIONS, prev, delta));
+      }
+    },
+    [availableLanguages, menuCursor, mode]
+  );
+  const startSession = useCallback(() => {
+    if (mode === "quote") {
+      if (quotes.length === 0) {
+        setErrorMessage("No quotes available for quote mode");
+        setPhase("error");
+        return;
+      }
+      const quote = quotes[Math.floor(Math.random() * quotes.length)];
+      const targetWords = quote.trim().split(/\s+/).filter((word) => word.length > 0);
+      if (targetWords.length === 0) {
+        setErrorMessage("Selected quote was empty");
+        setPhase("error");
+        return;
+      }
+      const next2 = new TypingSession({
+        mode,
+        durationSeconds: timeTargetSeconds,
+        targetWords
+      });
+      setSession(next2);
+      setNow(Date.now());
+      setPhase("running");
+      return;
+    }
+    const dictionary = dictionaries[language] ?? [];
+    if (dictionary.length === 0) {
+      setErrorMessage(`No words loaded for ${language}. Check engine-data path: ${ENGINE_DATA_DIR}`);
+      setPhase("error");
+      return;
+    }
+    const generated = generateWordSequence(dictionary, {
+      count: mode === "time" ? TIME_MODE_WORD_POOL : wordTarget,
+      punctuation: false,
+      numbers: false,
+      avoidConsecutiveRepeats: true
+    });
+    const next = new TypingSession({
+      mode,
+      durationSeconds: timeTargetSeconds,
+      targetWords: mode === "words" ? generated.slice(0, wordTarget) : generated
+    });
+    setSession(next);
+    setNow(Date.now());
+    setPhase("running");
+  }, [dictionaries, language, mode, quotes, timeTargetSeconds, wordTarget]);
+  const finalizeSession = useCallback(async () => {
+    if (!session || isFinalizing) return;
+    setIsFinalizing(true);
+    setPhase("saving");
+    try {
+      const result = session.buildResult(Date.now());
+      const nextStats = await saveResultAndUpdateStats(result);
+      setHistoryCount(nextStats.totalTests);
+      setAverageWpm(nextStats.averageWpm);
+      setAverageAccuracy(nextStats.averageAccuracy);
+      setLastResult(result);
+      setPhase("result");
+    } catch (error) {
+      setErrorMessage(error instanceof Error ? error.message : String(error));
+      setPhase("error");
+    } finally {
+      setIsFinalizing(false);
+    }
+  }, [isFinalizing, session]);
+  useEffect(() => {
+    if (phase !== "running" || !session) return;
+    const interval = setInterval(() => {
+      const tickNow = Date.now();
+      setNow(tickNow);
+      if (session.shouldAutoFinish(tickNow)) {
+        void finalizeSession();
+      }
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [finalizeSession, phase, session]);
+  const applyBackspace = useCallback(() => {
+    if (phase !== "running" || !session) return;
+    session.backspace();
+    setInputVersion((v) => v + 1);
+  }, [phase, session]);
+  const applyInputText = useCallback(
+    (input) => {
+      if (phase !== "running" || !session) return;
+      if (!input) return;
+      const chars = [...input];
+      const ts = Date.now();
+      for (const char of chars) {
+        session.applyCharacter(char, ts);
+      }
+      setInputVersion((v) => v + 1);
+      if (session.shouldAutoFinish(ts)) {
+        void finalizeSession();
+      }
+    },
+    [finalizeSession, phase, session]
+  );
+  const progress = useMemo(() => {
+    if (!session) return null;
+    return session.getProgress(now);
+  }, [now, session]);
+  const targetText = useMemo(() => session?.targetText ?? "", [session]);
+  const inputText = useMemo(() => {
+    void inputVersion;
+    return session?.input ?? "";
+  }, [inputVersion, session]);
+  const extraTyped = session && session.input.length > session.targetText.length ? session.input.slice(session.targetText.length) : "";
+  const remainingSeconds = session?.getRemainingSeconds(now) ?? 0;
+  const dictionarySize = dictionaries[language]?.length ?? 0;
+  return {
+    phase,
+    mode,
+    menuCursor,
+    menuItemCount,
+    language,
+    availableLanguages,
+    wordTarget,
+    wordTargetOptions: WORD_TARGET_OPTIONS,
+    timeTargetSeconds,
+    timeTargetOptions: TIME_TARGET_OPTIONS,
+    quoteCount: quotes.length,
+    dictionarySize,
+    historyCount,
+    averageWpm,
+    averageAccuracy,
+    errorMessage,
+    lastResult,
+    progress,
+    targetText,
+    inputText,
+    extraTyped,
+    remainingSeconds,
+    hasRunningSession: phase === "running" && session !== null,
+    engineDataDir: ENGINE_DATA_DIR,
+    resultsFilePath,
+    settingsFilePath,
+    statsFilePath,
+    moveMenuCursor,
+    adjustFocusedSetting,
+    startSession,
+    goToMenu: () => {
+      setSession(null);
+      setPhase("menu");
+    },
+    applyBackspace,
+    applyInputText
+  };
+}
+
+// apps/cli/src/components/screens.tsx
+import os2 from "node:os";
+import { Box as Box2, Text as Text2 } from "ink";
+
+// apps/cli/src/theme.ts
+function parseThemeMode(value) {
+  if (!value) return "auto";
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "high-contrast") return "high-contrast";
+  if (normalized === "mono" || normalized === "no-color") return "mono";
+  return "auto";
+}
+var THEME_MODE = parseThemeMode(process.env.MONKCLI_THEME);
+var noColorEnv = process.env.NO_COLOR !== void 0 || process.env.MONKCLI_NO_COLOR === "1" || process.env.MONKCLI_NO_COLOR === "true";
+var colorDepth = typeof process.stdout.getColorDepth === "function" ? process.stdout.getColorDepth() : 1;
+var ttySupportsColor = Boolean(process.stdout.isTTY) && colorDepth >= 4;
+var COLORS_ENABLED = THEME_MODE !== "mono" && ttySupportsColor && !noColorEnv;
+var HIGH_CONTRAST = THEME_MODE === "high-contrast" || !COLORS_ENABLED;
+
+// apps/cli/src/components/TargetTextView.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var LEFT_WINDOW = 28;
+var RIGHT_WINDOW = 52;
+function styleCorrect(char) {
+  return {
+    char,
+    bold: true
+  };
+}
+function styleIncorrect(char) {
+  return {
+    char,
+    color: COLORS_ENABLED ? "red" : void 0,
+    bold: true,
+    inverse: HIGH_CONTRAST,
+    underline: true
+  };
+}
+function styleUpcoming(char) {
+  return {
+    char,
+    color: COLORS_ENABLED ? "gray" : void 0,
+    dimColor: !HIGH_CONTRAST,
+    bold: false
+  };
+}
+function styleCurrent(char) {
+  return {
+    char,
+    color: COLORS_ENABLED ? "cyan" : void 0,
+    bold: true,
+    underline: HIGH_CONTRAST
+  };
+}
+function buildPastChars(targetText, inputText, pointer) {
+  const start = Math.max(0, pointer - LEFT_WINDOW);
+  const typedSlice = inputText.slice(start, pointer);
+  const visible = [];
+  for (let i = 0; i < typedSlice.length; i++) {
+    const char = typedSlice[i];
+    const absoluteIndex = start + i;
+    if (absoluteIndex < targetText.length) {
+      const isCorrect = char === targetText[absoluteIndex];
+      visible.push(isCorrect ? styleCorrect(char) : styleIncorrect(char));
+    } else {
+      visible.push(styleIncorrect(char));
+    }
+  }
+  if (start > 0 && visible.length > 0) {
+    visible[0] = {
+      char: "\u2026",
+      color: COLORS_ENABLED ? "gray" : void 0,
+      dimColor: !HIGH_CONTRAST,
+      bold: HIGH_CONTRAST
+    };
+  }
+  const padding = Array.from({ length: LEFT_WINDOW - visible.length }, () => ({
+    char: " "
+  }));
+  return [...padding, ...visible];
+}
+function buildFutureChars(targetText, pointer) {
+  const end = Math.min(targetText.length, pointer + RIGHT_WINDOW);
+  const visible = [];
+  for (let i = pointer; i < end; i++) {
+    const char = targetText[i];
+    visible.push(i === pointer ? styleCurrent(char) : styleUpcoming(char));
+  }
+  if (end < targetText.length && visible.length > 0) {
+    visible[visible.length - 1] = {
+      char: "\u2026",
+      color: COLORS_ENABLED ? "gray" : void 0,
+      dimColor: !HIGH_CONTRAST,
+      bold: HIGH_CONTRAST
+    };
+  }
+  const padding = Array.from({ length: RIGHT_WINDOW - visible.length }, () => ({
+    char: " "
+  }));
+  return [...visible, ...padding];
+}
+function renderChars(chars, keyPrefix) {
+  return chars.map((entry, index) => /* @__PURE__ */ jsx(
+    Text,
+    {
+      color: entry.color,
+      dimColor: entry.dimColor,
+      bold: entry.bold,
+      inverse: entry.inverse,
+      underline: entry.underline,
+      children: entry.char
+    },
+    `${keyPrefix}-${index}`
+  ));
+}
+function TargetTextView(props) {
+  const { targetText, inputText } = props;
+  if (!targetText || targetText.trim().length === 0) {
+    return /* @__PURE__ */ jsx(Box, { width: "100%", justifyContent: "center", children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "No target words" }) });
+  }
+  const pointer = Math.max(0, inputText.length);
+  const pastChars = buildPastChars(targetText, inputText, pointer);
+  const futureChars = buildFutureChars(targetText, pointer);
+  return /* @__PURE__ */ jsxs(Box, { width: "100%", justifyContent: "center", children: [
+    /* @__PURE__ */ jsx(Text, { children: renderChars(pastChars, "past") }),
+    /* @__PURE__ */ jsx(Text, { color: COLORS_ENABLED ? "yellow" : void 0, inverse: true, bold: true, children: "|" }),
+    /* @__PURE__ */ jsx(Text, { children: renderChars(futureChars, "future") })
+  ] });
+}
+
+// apps/cli/src/components/screens.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function compactPath(filePath) {
+  const home = os2.homedir();
+  return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+}
+function formatLanguageLabel(language) {
+  if (language === "english") return "english";
+  const match = language.match(/^english_(\d+)k$/);
+  if (match) {
+    return `english${match[1]}k`;
+  }
+  return language;
+}
+function RainbowTitle(props) {
+  const gradientStops = ["#00d4ff", "#4d7cff", "#a855f7", "#ff3d81"];
+  const hexToRgb = (hex) => {
+    const clean = hex.replace("#", "");
+    const r = Number.parseInt(clean.slice(0, 2), 16);
+    const g = Number.parseInt(clean.slice(2, 4), 16);
+    const b = Number.parseInt(clean.slice(4, 6), 16);
+    return [r, g, b];
+  };
+  const rgbToHex = (r, g, b) => `#${[r, g, b].map((value) => Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0")).join("")}`;
+  const interpolate = (a, b, t) => a + (b - a) * t;
+  const colorAt = (t) => {
+    if (gradientStops.length === 1) return gradientStops[0];
+    const segments = gradientStops.length - 1;
+    const scaled = t * segments;
+    const index = Math.min(segments - 1, Math.max(0, Math.floor(scaled)));
+    const localT = scaled - index;
+    const from = hexToRgb(gradientStops[index]);
+    const to = hexToRgb(gradientStops[index + 1]);
+    return rgbToHex(
+      interpolate(from[0], to[0], localT),
+      interpolate(from[1], to[1], localT),
+      interpolate(from[2], to[2], localT)
+    );
+  };
+  if (!COLORS_ENABLED) {
+    return /* @__PURE__ */ jsx2(Text2, { bold: true, children: props.text });
+  }
+  const chars = [...props.text];
+  return /* @__PURE__ */ jsx2(Text2, { bold: true, children: chars.map((char, index) => /* @__PURE__ */ jsx2(
+    Text2,
+    {
+      color: colorAt(chars.length <= 1 ? 0 : index / (chars.length - 1)),
+      children: char
+    },
+    `${char}-${index}`
+  )) });
+}
+function KeyTag(props) {
+  const tone = props.tone ?? "neutral";
+  const color = tone === "success" ? "green" : tone === "danger" ? "red" : tone === "primary" ? "cyan" : "yellow";
+  return /* @__PURE__ */ jsx2(
+    Text2,
+    {
+      color: COLORS_ENABLED ? color : void 0,
+      bold: true,
+      inverse: HIGH_CONTRAST && tone !== "neutral",
+      underline: HIGH_CONTRAST && tone === "primary",
+      children: props.label
+    }
+  );
+}
+function MenuControls() {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(KeyTag, { label: "\u2191/\u2193", tone: "primary" }),
+    " move row | ",
+    /* @__PURE__ */ jsx2(KeyTag, { label: "\u2190/\u2192", tone: "primary" }),
+    " change value | ",
+    /* @__PURE__ */ jsx2(KeyTag, { label: "Enter", tone: "success" }),
+    " start | ",
+    /* @__PURE__ */ jsx2(KeyTag, { label: "q", tone: "danger" }),
+    " quit"
+  ] });
+}
+function RunningControls() {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(KeyTag, { label: "Tab", tone: "primary" }),
+    " new test | ",
+    /* @__PURE__ */ jsx2(KeyTag, { label: "Enter", tone: "success" }),
+    " menu | ",
+    /* @__PURE__ */ jsx2(KeyTag, { label: "q", tone: "danger" }),
+    " quit"
+  ] });
+}
+function LoadingScreen() {
+  return /* @__PURE__ */ jsx2(Text2, { children: "Loading engine data..." });
+}
+function SavingScreen() {
+  return /* @__PURE__ */ jsx2(Text2, { children: "Saving result..." });
+}
+function ErrorScreen(props) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+      "Error: ",
+      props.errorMessage
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      /* @__PURE__ */ jsx2(KeyTag, { label: "Enter", tone: "success" }),
+      " menu | ",
+      /* @__PURE__ */ jsx2(KeyTag, { label: "q", tone: "danger" }),
+      " quit"
+    ] })
+  ] });
+}
+function MenuScreen(props) {
+  const {
+    language,
+    availableLanguages,
+    mode,
+    menuCursor,
+    menuItemCount,
+    timeTargetSeconds,
+    timeTargetOptions,
+    wordTarget,
+    wordTargetOptions,
+    quoteCount,
+    dictionarySize,
+    historyCount,
+    averageWpm,
+    averageAccuracy,
+    resultsFilePath,
+    settingsFilePath,
+    statsFilePath,
+    engineDataDir
+  } = props;
+  const modeDetail = mode === "time" ? `seconds: ${timeTargetSeconds} [${timeTargetOptions.join(", ")}]` : `words: ${wordTarget} [${wordTargetOptions.join(", ")}]`;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx2(RainbowTitle, { text: "monkcli" }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      "history: ",
+      historyCount,
+      " | avg: ",
+      Math.round(averageWpm),
+      " wpm,",
+      " ",
+      Math.round(averageAccuracy),
+      "% acc | dictionary words: ",
+      dictionarySize,
+      " | quotes:",
+      " ",
+      quoteCount
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      "results: ",
+      compactPath(resultsFilePath),
+      " | stats: ",
+      compactPath(statsFilePath),
+      " | settings:",
+      " ",
+      compactPath(settingsFilePath)
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { children: " " }),
+    /* @__PURE__ */ jsxs2(Text2, { color: menuCursor === 0 ? "green" : "white", children: [
+      menuCursor === 0 ? ">" : " ",
+      " language: ",
+      formatLanguageLabel(language),
+      " (",
+      availableLanguages.length,
+      " options)"
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { color: menuCursor === 1 ? "green" : "white", children: [
+      menuCursor === 1 ? ">" : " ",
+      " mode: ",
+      mode
+    ] }),
+    mode !== "quote" ? /* @__PURE__ */ jsxs2(Text2, { color: menuCursor === 2 ? "green" : "white", children: [
+      menuCursor === 2 ? ">" : " ",
+      " ",
+      modeDetail
+    ] }) : /* @__PURE__ */ jsx2(Text2, { color: "gray", dimColor: true, children: "quote source: english" }),
+    /* @__PURE__ */ jsx2(Text2, { children: " " }),
+    /* @__PURE__ */ jsx2(MenuControls, {}),
+    /* @__PURE__ */ jsxs2(Text2, { color: "gray", dimColor: true, children: [
+      "active rows: ",
+      menuItemCount
+    ] }),
+    dictionarySize === 0 && mode !== "quote" ? /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+      "Cannot start: dictionary is empty. engine-data path: ",
+      engineDataDir
+    ] }) : null,
+    quoteCount === 0 && mode === "quote" ? /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+      "Cannot start: quote list is empty. engine-data path: ",
+      engineDataDir
+    ] }) : null
+  ] });
+}
+function ResultScreen(props) {
+  const { result, historyCount, averageWpm, averageAccuracy, resultsFilePath } = props;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { color: "green", bold: true, children: "Test complete" }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      Math.round(result.wpm),
+      " wpm | ",
+      Math.round(result.rawWpm),
+      " raw | ",
+      Math.round(result.accuracy),
+      "% acc"
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "time" }),
+      " ",
+      Math.round(result.elapsedSeconds),
+      "s |",
+      " ",
+      /* @__PURE__ */ jsx2(Text2, { color: "green", children: "correct keys" }),
+      " ",
+      /* @__PURE__ */ jsx2(Text2, { color: "green", bold: true, children: result.accuracyCounts.correct }),
+      " ",
+      "| ",
+      /* @__PURE__ */ jsx2(Text2, { color: "red", children: "incorrect keys" }),
+      " ",
+      /* @__PURE__ */ jsx2(Text2, { color: "red", bold: true, children: result.accuracyCounts.incorrect })
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      "saved results: ",
+      historyCount,
+      " (",
+      compactPath(resultsFilePath),
+      ")"
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      "average: ",
+      Math.round(averageWpm),
+      " wpm | ",
+      Math.round(averageAccuracy),
+      "% acc"
+    ] }),
+    /* @__PURE__ */ jsx2(RunningControls, {})
+  ] });
+}
+function RunningScreen(props) {
+  const { mode, remainingSeconds, progress, targetText, inputText, extraTyped } = props;
+  const modeLabel = mode === "time" ? `time | ${Math.max(0, Math.ceil(remainingSeconds))}s left` : mode;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: modeLabel }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      Math.round(progress?.wpm ?? 0),
+      " wpm | ",
+      Math.round(progress?.accuracy ?? 100),
+      "% acc"
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { children: " " }),
+    /* @__PURE__ */ jsx2(TargetTextView, { targetText, inputText }),
+    extraTyped.length > 0 ? /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+      "extra: ",
+      extraTyped
+    ] }) : null,
+    /* @__PURE__ */ jsx2(Text2, { children: " " }),
+    /* @__PURE__ */ jsx2(RunningControls, {})
+  ] });
+}
+
+// apps/cli/src/App.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function App() {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const terminalWidth = stdout.columns ?? 120;
+  const terminalHeight = stdout.rows ?? 30;
+  const controller = useTypingController();
+  const safeWidth = Math.max(40, terminalWidth);
+  const safeHeight = Math.max(12, terminalHeight);
+  const panelWidth = Math.max(36, Math.min(safeWidth - 2, 120));
+  const renderCentered = (content) => /* @__PURE__ */ jsx3(Box3, { width: safeWidth, height: safeHeight, justifyContent: "center", alignItems: "center", children: /* @__PURE__ */ jsx3(Box3, { width: panelWidth, flexDirection: "column", children: content }) });
+  useInput((input, key) => {
+    if (key.ctrl && input === "c" || input === "q") {
+      exit();
+      return;
+    }
+    if (controller.phase === "menu") {
+      if (key.upArrow) {
+        controller.moveMenuCursor(-1);
+        return;
+      }
+      if (key.downArrow) {
+        controller.moveMenuCursor(1);
+        return;
+      }
+      if (key.leftArrow) {
+        controller.adjustFocusedSetting(-1);
+        return;
+      }
+      if (key.rightArrow) {
+        controller.adjustFocusedSetting(1);
+        return;
+      }
+      if (key.return) {
+        controller.startSession();
+      }
+      return;
+    }
+    if (controller.phase === "result") {
+      if (key.tab) {
+        controller.startSession();
+        return;
+      }
+      if (key.return) {
+        controller.goToMenu();
+      }
+      return;
+    }
+    if (controller.phase === "error") {
+      if (key.return) {
+        controller.goToMenu();
+      }
+      return;
+    }
+    if (!controller.hasRunningSession) return;
+    if (key.tab) {
+      controller.startSession();
+      return;
+    }
+    if (key.return) {
+      controller.goToMenu();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      controller.applyBackspace();
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      controller.applyInputText(input);
+    }
+  });
+  if (controller.phase === "loading") {
+    return renderCentered(/* @__PURE__ */ jsx3(LoadingScreen, {}));
+  }
+  if (controller.phase === "error") {
+    return renderCentered(/* @__PURE__ */ jsx3(ErrorScreen, { errorMessage: controller.errorMessage }));
+  }
+  if (controller.phase === "menu") {
+    return renderCentered(
+      /* @__PURE__ */ jsx3(
+        MenuScreen,
+        {
+          language: controller.language,
+          availableLanguages: controller.availableLanguages,
+          mode: controller.mode,
+          menuCursor: controller.menuCursor,
+          menuItemCount: controller.menuItemCount,
+          timeTargetSeconds: controller.timeTargetSeconds,
+          timeTargetOptions: controller.timeTargetOptions,
+          wordTarget: controller.wordTarget,
+          wordTargetOptions: controller.wordTargetOptions,
+          quoteCount: controller.quoteCount,
+          dictionarySize: controller.dictionarySize,
+          historyCount: controller.historyCount,
+          averageWpm: controller.averageWpm,
+          averageAccuracy: controller.averageAccuracy,
+          resultsFilePath: controller.resultsFilePath,
+          settingsFilePath: controller.settingsFilePath,
+          statsFilePath: controller.statsFilePath,
+          engineDataDir: controller.engineDataDir
+        }
+      )
+    );
+  }
+  if (controller.phase === "saving") {
+    return renderCentered(/* @__PURE__ */ jsx3(SavingScreen, {}));
+  }
+  if (controller.phase === "result" && controller.lastResult) {
+    return renderCentered(
+      /* @__PURE__ */ jsx3(
+        ResultScreen,
+        {
+          result: controller.lastResult,
+          historyCount: controller.historyCount,
+          averageWpm: controller.averageWpm,
+          averageAccuracy: controller.averageAccuracy,
+          resultsFilePath: controller.resultsFilePath
+        }
+      )
+    );
+  }
+  return renderCentered(
+    /* @__PURE__ */ jsx3(
+      RunningScreen,
+      {
+        mode: controller.mode,
+        remainingSeconds: controller.remainingSeconds,
+        progress: controller.progress,
+        targetText: controller.targetText,
+        inputText: controller.inputText,
+        extraTyped: controller.extraTyped
+      }
+    )
+  );
+}
+
+// apps/cli/src/index.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+render(/* @__PURE__ */ jsx4(App, {}));