saterminal 0.3.2 → 0.5.0

package/src/focus.ts

@@ -1,231 +0,0 @@
-import type { Difficulty, Domain, Focus, Skill } from "./types.ts";
-
-export const difficultyOptions = ["E", "M", "H"] as const satisfies readonly Difficulty[];
-export const domainOptions = ["INI", "CAS", "EOI", "SEC"] as const satisfies readonly Domain[];
-export const skillOptions = ["CID", "INF", "COE", "WIC", "TSP", "CTC", "SYN", "TRA", "BOU", "FSS"] as const satisfies readonly Skill[];
-
-export const skillsByDomain: Record<Domain, readonly Skill[]> = {
-  INI: ["CID", "INF", "COE"],
-  CAS: ["WIC", "TSP", "CTC"],
-  EOI: ["SYN", "TRA"],
-  SEC: ["BOU", "FSS"],
-};
-
-export const defaultFocus: Focus = {
-  difficulties: ["M", "H"],
-  domains: [...domainOptions],
-  skills: [...skillOptions],
-};
-
-export type FocusGroup = "difficulties" | "domains" | "skills";
-
-export type FocusRow =
-  | { kind: "header"; label: string }
-  | {
-    kind: "option";
-    group: FocusGroup;
-    value: Difficulty | Domain | Skill;
-    label: string;
-    checked: boolean;
-    partial?: boolean;
-    depth: number;
-  };
-
-export function normalizeFocus(value: unknown): Focus {
-  const raw = value && typeof value === "object" ? value as Partial<Record<keyof Focus, unknown>> : {};
-  const skills = normalizeSkills(raw.skills, raw.domains);
-  return {
-    difficulties: normalizeSelection(raw.difficulties, difficultyOptions, defaultFocus.difficulties),
-    domains: domainsForSkills(skills),
-    skills,
-  };
-}
-
-export function domainsForSkills(skills: readonly Skill[]): Domain[] {
-  return domainOptions.filter((domain) => skillsForDomain(domain).some((skill) => skills.includes(skill)));
-}
-
-export function skillsForDomain(domain: Domain): readonly Skill[] {
-  return skillsByDomain[domain];
-}
-
-export function focusSummary(focus: Focus): string {
-  const difficulty = focus.difficulties.join(",");
-  const skillCount = focus.skills.length;
-  const domainCount = focus.domains.length;
-  return `${skillCount} skills · ${difficulty} · ${domainCount} domains`;
-}
-
-export function focusRows(focus: Focus): FocusRow[] {
-  return [
-    { kind: "header", label: "Difficulty" },
-    ...difficultyOptions.map((value) => optionRow("difficulties", value, difficultyLabels[value], focus.difficulties.includes(value), 0)),
-    { kind: "header", label: "Reading and Writing" },
-    ...domainOptions.flatMap((domain) => domainRows(domain, focus)),
-  ];
-}
-
-export function toggleFocusRow(focus: Focus, row: FocusRow | undefined): Focus {
-  if (!row || row.kind !== "option") {
-    return focus;
-  }
-
-  if (row.group === "domains") {
-    return toggleDomainFocus(focus, row.value as Domain);
-  }
-
-  if (row.group === "difficulties") {
-    return toggleDifficultyFocus(focus, row.value as Difficulty);
-  }
-
-  return toggleSkillFocus(focus, row.value as Skill);
-}
-
-export function nextFocusableIndex(rows: FocusRow[], current: number): number {
-  for (let index = Math.min(current + 1, rows.length - 1); index < rows.length; index++) {
-    if (rows[index]?.kind === "option") {
-      return index;
-    }
-  }
-  return current;
-}
-
-export function previousFocusableIndex(rows: FocusRow[], current: number): number {
-  for (let index = Math.max(current - 1, 0); index >= 0; index--) {
-    if (rows[index]?.kind === "option") {
-      return index;
-    }
-  }
-  return current;
-}
-
-function domainRows(domain: Domain, focus: Focus): FocusRow[] {
-  const skills = skillsForDomain(domain);
-  const selected = skills.filter((skill) => focus.skills.includes(skill));
-  return [
-    optionRow("domains", domain, domainLabels[domain], selected.length > 0, 0, selected.length > 0 && selected.length < skills.length),
-    ...skills.map((skill) => optionRow("skills", skill, skillLabels[skill], focus.skills.includes(skill), 1)),
-  ];
-}
-
-function optionRow(
-  group: FocusGroup,
-  value: Difficulty | Domain | Skill,
-  label: string,
-  checked: boolean,
-  depth: number,
-  partial = false,
-): FocusRow {
-  return { kind: "option", group, value, label: `${value}  ${label}`, checked, partial, depth };
-}
-
-function toggleDifficultyFocus(focus: Focus, difficulty: Difficulty): Focus {
-  const selected = focus.difficulties.includes(difficulty);
-  if (selected && focus.difficulties.length === 1) {
-    return focus;
-  }
-
-  return {
-    ...focus,
-    difficulties: selected
-      ? focus.difficulties.filter((value) => value !== difficulty)
-      : unique([...focus.difficulties, difficulty]),
-  };
-}
-
-function toggleSkillFocus(focus: Focus, skill: Skill): Focus {
-  const selected = focus.skills.includes(skill);
-  if (selected && focus.skills.length === 1) {
-    return focus;
-  }
-
-  const skills = selected ? focus.skills.filter((value) => value !== skill) : unique([...focus.skills, skill]);
-  return {
-    ...focus,
-    domains: domainsForSkills(skills),
-    skills,
-  };
-}
-
-function toggleDomainFocus(focus: Focus, domain: Domain): Focus {
-  const domainSkills = skillsForDomain(domain);
-  const allSelected = domainSkills.every((skill) => focus.skills.includes(skill));
-
-  if (allSelected) {
-    const remaining = focus.skills.filter((skill) => !domainSkills.includes(skill));
-    if (remaining.length === 0) {
-      return focus;
-    }
-
-    return {
-      ...focus,
-      domains: domainsForSkills(remaining),
-      skills: remaining,
-    };
-  }
-
-  const skills = unique([...focus.skills, ...domainSkills]);
-  return {
-    ...focus,
-    domains: domainsForSkills(skills),
-    skills,
-  };
-}
-
-function normalizeSelection<T extends string>(value: unknown, options: readonly T[], fallback: readonly T[]): T[] {
-  if (!Array.isArray(value)) {
-    return [...fallback];
-  }
-
-  const selected = options.filter((option) => value.includes(option));
-  return selected.length > 0 ? selected : [...fallback];
-}
-
-function normalizeSkills(value: unknown, domains: unknown): Skill[] {
-  if (Array.isArray(value)) {
-    const selected = skillOptions.filter((option) => value.includes(option));
-    if (selected.length > 0) {
-      return selected;
-    }
-  }
-
-  if (Array.isArray(domains)) {
-    const selectedDomains = domainOptions.filter((option) => domains.includes(option));
-    const selectedSkills = selectedDomains.flatMap((domain) => [...skillsForDomain(domain)]);
-    if (selectedSkills.length > 0) {
-      return selectedSkills;
-    }
-  }
-
-  return [...defaultFocus.skills];
-}
-
-function unique<T>(values: T[]): T[] {
-  return values.filter((value, index, list) => list.indexOf(value) === index);
-}
-
-export const difficultyLabels: Record<Difficulty, string> = {
-  E: "Easy",
-  M: "Medium",
-  H: "Hard",
-};
-
-export const domainLabels: Record<Domain, string> = {
-  INI: "Information and Ideas",
-  CAS: "Craft and Structure",
-  EOI: "Expression of Ideas",
-  SEC: "Standard English Conventions",
-};
-
-export const skillLabels: Record<Skill, string> = {
-  CID: "Central Ideas and Details",
-  INF: "Inferences",
-  COE: "Command of Evidence",
-  WIC: "Words in Context",
-  TSP: "Text Structure and Purpose",
-  CTC: "Cross-Text Connections",
-  SYN: "Transitions",
-  TRA: "Rhetorical Synthesis",
-  BOU: "Boundaries",
-  FSS: "Form, Structure, and Sense",
-};

package/src/main.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env bun
-import { parseArgs, runCliCommand } from "./cli.ts";
-import { runTui } from "./tui.ts";
-
-const parsed = parseArgs(process.argv.slice(2));
-
-if (parsed.kind === "tui") {
-  await runTui();
-} else if (parsed.kind === "review") {
-  await runTui({ mode: "review" });
-} else {
-  process.exitCode = await runCliCommand(parsed);
-}

package/src/progress.ts

@@ -1,48 +0,0 @@
-const partialBlocks = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"] as const;
-
-export type ProgressBar = {
-  filled: string;
-  partial: string;
-  empty: string;
-  fullCells: number;
-  emptyCells: number;
-};
-
-export function progressBar(ratio: number, width: number): ProgressBar {
-  const normalized = Number.isFinite(ratio) ? Math.min(1, Math.max(0, ratio)) : 0;
-  const cells = Math.max(0, Math.floor(width));
-  const exact = normalized * cells;
-  const full = Math.floor(exact);
-  const partial = Math.round((exact - full) * 8);
-
-  if (cells === 0) {
-    return { filled: "", partial: "", empty: "", fullCells: 0, emptyCells: 0 };
-  }
-
-  if (partial === 8 && full < cells) {
-    const fullCells = full + 1;
-    const emptyCells = cells - fullCells;
-    return {
-      filled: "█".repeat(fullCells),
-      partial: "",
-      empty: " ".repeat(emptyCells),
-      fullCells,
-      emptyCells,
-    };
-  }
-
-  const partialBlock = full < cells ? partialBlocks[partial] : "";
-  const emptyCells = cells - full - (partialBlock ? 1 : 0);
-  return {
-    filled: "█".repeat(full),
-    partial: partialBlock,
-    empty: " ".repeat(emptyCells),
-    fullCells: full,
-    emptyCells,
-  };
-}
-
-export function progressBarText(ratio: number, width: number): string {
-  const bar = progressBar(ratio, width);
-  return `${bar.filled}${bar.partial}${bar.empty}`;
-}

package/src/state.ts

@@ -1,346 +0,0 @@
-import { appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join, sep } from "node:path";
-import { defaultFocus, normalizeFocus } from "./focus.ts";
-import type { Attempt, AttemptEvent, Focus, Outcome, QuestionMeta, SummaryRow } from "./types.ts";
-
-export function resolveStateDir(home = homedir()): string {
-  return join(home, ".saterminal", "userlocal");
-}
-
-export function displayStateDir(dir: string, home = homedir()): string {
-  if (dir === home) {
-    return "~";
-  }
-
-  const prefix = `${home}${sep}`;
-  if (dir.startsWith(prefix)) {
-    return `~${dir.slice(home.length)}`;
-  }
-
-  return dir;
-}
-
-export const stateDir = resolveStateDir();
-export const attemptsPath = join(stateDir, "attempts.csv");
-export const eventsPath = join(stateDir, "events.csv");
-export const summaryPath = join(stateDir, "summary.csv");
-export const focusPath = join(stateDir, "focus.json");
-
-const attemptsHeader = "question_id,outcome,updated_at,elapsed_seconds,difficulty,domain,domain_desc,skill,skill_desc";
-const eventsHeader = "question_id,correct,answered_at,elapsed_seconds,difficulty,domain,domain_desc,skill,skill_desc";
-const summaryHeader = "metric,value,updated_at";
-
-export async function stateDirExists(dir = stateDir): Promise<boolean> {
-  try {
-    return (await stat(dir)).isDirectory();
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-      return false;
-    }
-
-    throw error;
-  }
-}
-
-export async function ensureStateFiles(dir = stateDir): Promise<void> {
-  await mkdir(dir, { recursive: true });
-  await ensureFile(join(dir, "attempts.csv"), `${attemptsHeader}\n`);
-  await ensureFile(join(dir, "events.csv"), `${eventsHeader}\n`);
-  await ensureFile(join(dir, "summary.csv"), `${summaryHeader}\n`);
-  await ensureFile(join(dir, "focus.json"), `${JSON.stringify(defaultFocus, null, 2)}\n`);
-}
-
-export async function loadAttempts(path = attemptsPath): Promise<Map<string, Attempt>> {
-  await ensureFile(path, `${attemptsHeader}\n`);
-  const raw = await readFile(path, "utf8");
-  const rows = parseCsv(raw);
-  const attempts = new Map<string, Attempt>();
-
-  for (const row of rows.slice(1)) {
-    const [question_id, outcome, updated_at, elapsed_seconds, difficulty, domain, domain_desc, skill, skill_desc] = row;
-    if (!question_id || !isOutcome(outcome) || !updated_at) {
-      continue;
-    }
-
-    attempts.set(question_id, {
-      question_id,
-      outcome,
-      updated_at,
-      elapsed_seconds: readElapsedSeconds(elapsed_seconds),
-      ...optionalMetadata({ difficulty, domain, domain_desc, skill, skill_desc }),
-    });
-  }
-
-  return attempts;
-}
-
-export async function saveAttempts(attempts: Map<string, Attempt>, path = attemptsPath): Promise<void> {
-  await mkdir(dirname(path), { recursive: true });
-  const rows = [...attempts.values()]
-    .sort((a, b) => a.updated_at.localeCompare(b.updated_at))
-    .map((attempt) => [
-      attempt.question_id,
-      attempt.outcome,
-      attempt.updated_at,
-      String(attempt.elapsed_seconds),
-      attempt.difficulty ?? "",
-      attempt.domain ?? "",
-      attempt.domain_desc ?? "",
-      attempt.skill ?? "",
-      attempt.skill_desc ?? "",
-    ]);
-
-  await writeFile(path, formatCsv([attemptsHeader.split(","), ...rows]), "utf8");
-}
-
-export async function loadAttemptEvents(path = eventsPath): Promise<AttemptEvent[]> {
-  await ensureFile(path, `${eventsHeader}\n`);
-  const raw = await readFile(path, "utf8");
-  const rows = parseCsv(raw);
-  const events: AttemptEvent[] = [];
-
-  for (const row of rows.slice(1)) {
-    const [question_id, correct, answered_at, elapsed_seconds, difficulty, domain, domain_desc, skill, skill_desc] = row;
-    if (!question_id || !isBooleanText(correct) || !answered_at) {
-      continue;
-    }
-
-    events.push({
-      question_id,
-      correct: correct === "true",
-      answered_at,
-      elapsed_seconds: readElapsedSeconds(elapsed_seconds),
-      difficulty: difficulty ?? "",
-      domain: domain ?? "",
-      domain_desc: domain_desc || undefined,
-      skill: skill ?? "",
-      skill_desc: skill_desc || undefined,
-    });
-  }
-
-  return events;
-}
-
-export async function appendAttemptEvent(
-  meta: QuestionMeta,
-  correct: boolean,
-  elapsedSeconds = 0,
-  now = new Date(),
-  path = eventsPath,
-): Promise<AttemptEvent> {
-  const event: AttemptEvent = {
-    question_id: meta.questionId,
-    correct,
-    answered_at: now.toISOString(),
-    elapsed_seconds: elapsedSeconds,
-    difficulty: meta.difficulty,
-    domain: meta.primary_class_cd,
-    domain_desc: meta.primary_class_cd_desc,
-    skill: meta.skill_cd,
-    skill_desc: meta.skill_desc,
-  };
-
-  await ensureFile(path, `${eventsHeader}\n`);
-  await appendFile(path, formatCsv([attemptEventRow(event)]), "utf8");
-  return event;
-}
-
-export function recordAttempt(
-  attempts: Map<string, Attempt>,
-  questionId: string,
-  wasCorrect: boolean,
-  elapsedSeconds = 0,
-  now = new Date(),
-  meta?: QuestionMeta,
-): Attempt {
-  const existing = attempts.get(questionId);
-  const updated_at = now.toISOString();
-  const outcome = nextOutcome(existing?.outcome, wasCorrect);
-  const attempt = {
-    question_id: questionId,
-    outcome,
-    updated_at,
-    elapsed_seconds: elapsedSeconds,
-    ...metadataFromQuestionMeta(meta),
-  };
-  attempts.set(questionId, attempt);
-  return attempt;
-}
-
-export function nextOutcome(previous: Outcome | undefined, wasCorrect: boolean): Outcome {
-  if (previous === "correct" || previous === "corrected") {
-    return previous;
-  }
-
-  if (previous === "incorrect" && wasCorrect) {
-    return "corrected";
-  }
-
-  return wasCorrect ? "correct" : "incorrect";
-}
-
-export function buildSummaryRows(attempts: Map<string, Attempt>, now = new Date()): SummaryRow[] {
-  const updated_at = now.toISOString();
-  const values = [...attempts.values()];
-  const total = values.length;
-  const correct = values.filter((attempt) => attempt.outcome === "correct").length;
-  const incorrect = values.filter((attempt) => attempt.outcome === "incorrect").length;
-  const corrected = values.filter((attempt) => attempt.outcome === "corrected").length;
-  const mastered = correct + corrected;
-  const accuracy = total === 0 ? "0.00" : (mastered / total).toFixed(2);
-  const totalSeconds = values.reduce((sum, attempt) => sum + attempt.elapsed_seconds, 0);
-  const avgSeconds = total === 0 ? 0 : totalSeconds / total;
-
-  return [
-    { metric: "answered", value: String(total), updated_at },
-    { metric: "correct", value: String(correct), updated_at },
-    { metric: "incorrect", value: String(incorrect), updated_at },
-    { metric: "corrected", value: String(corrected), updated_at },
-    { metric: "accuracy", value: accuracy, updated_at },
-    { metric: "avg_seconds", value: avgSeconds.toFixed(1), updated_at },
-  ];
-}
-
-export async function saveSummary(attempts: Map<string, Attempt>, path = summaryPath): Promise<void> {
-  await mkdir(dirname(path), { recursive: true });
-  const rows = buildSummaryRows(attempts).map((row) => [row.metric, row.value, row.updated_at]);
-  await writeFile(path, formatCsv([summaryHeader.split(","), ...rows]), "utf8");
-}
-
-export async function loadFocus(path = focusPath): Promise<Focus> {
-  await ensureFile(path, `${JSON.stringify(defaultFocus, null, 2)}\n`);
-  const raw = await readFile(path, "utf8");
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`Invalid focus file at ${path}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-
-  return normalizeFocus(parsed);
-}
-
-export async function saveFocus(focus: Focus, path = focusPath): Promise<void> {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(normalizeFocus(focus), null, 2)}\n`, "utf8");
-}
-
-function isOutcome(value: string | undefined): value is Outcome {
-  return value === "correct" || value === "incorrect" || value === "corrected";
-}
-
-function isBooleanText(value: string | undefined): value is "true" | "false" {
-  return value === "true" || value === "false";
-}
-
-function readElapsedSeconds(value: string | undefined): number {
-  const seconds = Number(value);
-  return Number.isFinite(seconds) && seconds >= 0 ? seconds : 0;
-}
-
-function metadataFromQuestionMeta(meta: QuestionMeta | undefined): Partial<Attempt> {
-  if (!meta) {
-    return {};
-  }
-
-  return optionalMetadata({
-    difficulty: meta.difficulty,
-    domain: meta.primary_class_cd,
-    domain_desc: meta.primary_class_cd_desc,
-    skill: meta.skill_cd,
-    skill_desc: meta.skill_desc,
-  });
-}
-
-function optionalMetadata(metadata: Pick<Attempt, "difficulty" | "domain" | "domain_desc" | "skill" | "skill_desc">): Partial<Attempt> {
-  return Object.fromEntries(Object.entries(metadata).filter(([, value]) => value)) as Partial<Attempt>;
-}
-
-function attemptEventRow(event: AttemptEvent): string[] {
-  return [
-    event.question_id,
-    String(event.correct),
-    event.answered_at,
-    String(event.elapsed_seconds),
-    event.difficulty,
-    event.domain,
-    event.domain_desc ?? "",
-    event.skill,
-    event.skill_desc ?? "",
-  ];
-}
-
-async function ensureFile(path: string, contents: string): Promise<void> {
-  try {
-    await readFile(path, "utf8");
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-      throw error;
-    }
-
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, contents, "utf8");
-  }
-}
-
-function parseCsv(raw: string): string[][] {
-  const rows: string[][] = [];
-  let row: string[] = [];
-  let field = "";
-  let quoted = false;
-
-  for (let index = 0; index < raw.length; index += 1) {
-    const char = raw[index];
-    const next = raw[index + 1];
-
-    if (quoted) {
-      if (char === "\"" && next === "\"") {
-        field += "\"";
-        index += 1;
-      } else if (char === "\"") {
-        quoted = false;
-      } else {
-        field += char;
-      }
-      continue;
-    }
-
-    if (char === "\"") {
-      quoted = true;
-    } else if (char === ",") {
-      row.push(field.trim());
-      field = "";
-    } else if (char === "\n") {
-      row.push(field.trim());
-      if (row.some((value) => value.length > 0)) {
-        rows.push(row);
-      }
-      row = [];
-      field = "";
-    } else if (char !== "\r") {
-      field += char;
-    }
-  }
-
-  if (field.length > 0 || row.length > 0) {
-    row.push(field.trim());
-    if (row.some((value) => value.length > 0)) {
-      rows.push(row);
-    }
-  }
-
-  return rows;
-}
-
-function formatCsv(rows: string[][]): string {
-  return `${rows.map((row) => row.map(csvEscape).join(",")).join("\n")}\n`;
-}
-
-function csvEscape(value: string): string {
-  if (!/[",\n\r]/.test(value)) {
-    return value;
-  }
-
-  return `"${value.replaceAll("\"", "\"\"")}"`;
-}