saterminal 0.2.0 → 0.3.1

package/flake.lock

@@ -1,59 +0,0 @@
-{
-  "nodes": {
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1731533236,
-        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1781577229,
-        "narHash": "sha256-lrp67w8AulE9Ks53n27I45ADSzbOCn4H+CNW1Ck8B+8=",
-        "rev": "567a49d1913ce81ac6e9582e3553dd90a955875f",
-        "revCount": 1017464,
-        "type": "tarball",
-        "url": "https://api.flakehub.com/f/pinned/DeterminateSystems/nixpkgs-weekly/0.1.1017464%2Brev-567a49d1913ce81ac6e9582e3553dd90a955875f/019f1749-32d6-7283-9e9a-861bd8478e6a/source.tar.gz"
-      },
-      "original": {
-        "type": "tarball",
-        "url": "https://flakehub.com/f/DeterminateSystems/nixpkgs-weekly/0.tar.gz"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

package/flake.nix

@@ -1,21 +0,0 @@
-{
-  inputs = {
-    nixpkgs.url = "https://flakehub.com/f/DeterminateSystems/nixpkgs-weekly/0.tar.gz";
-    flake-utils.url = "github:numtide/flake-utils";
-  };
-
-  outputs = { nixpkgs, flake-utils, ... }:
-    flake-utils.lib.eachDefaultSystem (
-      system:
-      let
-        pkgs = import nixpkgs { inherit system; };
-      in
-      {
-        devShells.default = pkgs.mkShell {
-          packages = with pkgs; [
-            bun
-          ];
-        };
-      }
-    );
-}

package/src/tui/terminal.ts

@@ -1,110 +0,0 @@
-import { wrapText } from "../text.ts";
-import type { TextSegment } from "../text.ts";
-import { term, gutter, terminalSize } from "./kit.ts";
-
-export { term, gutter, terminalSize, contentBounds } from "./kit.ts";
-
-export function line(y: number, value: string): void {
-  term.moveTo(1, y)(value.slice(0, term.width - 1));
-}
-
-export function lineAt(x: number, y: number, width: number, value: string): void {
-  term.moveTo(x, y)(value.slice(0, width));
-}
-
-export function lineAtColor(
-  x: number,
-  y: number,
-  width: number,
-  value: string,
-  color: "cyan" | "green" | "red" | "yellow",
-  bold = false,
-): void {
-  const output = value.slice(0, width);
-  if (bold) {
-    term.moveTo(x, y).bold[color](output);
-  } else {
-    term.moveTo(x, y)[color](output);
-  }
-}
-
-export function paneLayout(): {
-  leftX: number;
-  leftWidth: number;
-  rightX: number;
-  rightWidth: number;
-} {
-  const { width } = terminalSize();
-  const usable = Math.max(40, width - gutter);
-  const leftWidth = Math.max(20, Math.floor(usable / 2));
-  const rightX = leftWidth + gutter + 1;
-  const rightWidth = Math.max(20, width - rightX);
-
-  return {
-    leftX: 1,
-    leftWidth,
-    rightX,
-    rightWidth,
-  };
-}
-
-export function printWrapped(value: string | undefined, y: number, maxY: number, bold = false): number {
-  return printWrappedAt(value, 1, y, terminalSize().width - 4, maxY, bold);
-}
-
-export function printWrappedAt(
-  value: string | undefined,
-  x: number,
-  y: number,
-  width: number,
-  maxY: number,
-  bold = false,
-): number {
-  for (const row of wrapText(value ?? "", width)) {
-    if (y > maxY) {
-      lineAt(x, y, width, "...");
-      return y + 1;
-    }
-    if (bold) {
-      term.moveTo(x, y++).bold(row.slice(0, width));
-    } else {
-      lineAt(x, y++, width, row);
-    }
-  }
-
-  return y;
-}
-
-export function renderStyledLine(
-  x: number,
-  y: number,
-  width: number,
-  segments: TextSegment[],
-  forceBold = false,
-): void {
-  let col = 0;
-
-  for (const segment of segments) {
-    if (col >= width) {
-      break;
-    }
-
-    const text = segment.text.slice(0, width - col);
-    if (!text) {
-      continue;
-    }
-
-    const bold = forceBold || segment.style.bold;
-    const underline = segment.style.underline;
-    let output = term.moveTo(x + col, y);
-    if (bold && underline) {
-      output = output.bold.underline;
-    } else if (bold) {
-      output = output.bold;
-    } else if (underline) {
-      output = output.underline;
-    }
-    output(text);
-    col += text.length;
-  }
-}

package/test/api.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { fetchQuestionBank } from "../src/api.ts";
-
-describe("api", () => {
-  test("passes excluded short question ids to the question bank endpoint", async () => {
-    const originalFetch = globalThis.fetch;
-    let requested = "";
-    globalThis.fetch = ((input: RequestInfo | URL) => {
-      requested = String(input);
-      return Promise.resolve(
-        new Response(JSON.stringify({ success: true, data: [] }), {
-          status: 200,
-          headers: { "content-type": "application/json" },
-        }),
-      );
-    }) as typeof fetch;
-
-    try {
-      await fetchQuestionBank(["a", "b"]);
-      expect(requested).toContain("assessment=SAT");
-      expect(requested).toContain("excludeIds=a%2Cb");
-      expect(requested).toContain("difficulties=M%2CH");
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  test("passes focus filters to the question bank endpoint", async () => {
-    const originalFetch = globalThis.fetch;
-    let requested = "";
-    globalThis.fetch = ((input: RequestInfo | URL) => {
-      requested = String(input);
-      return Promise.resolve(
-        new Response(JSON.stringify({ success: true, data: [] }), {
-          status: 200,
-          headers: { "content-type": "application/json" },
-        }),
-      );
-    }) as typeof fetch;
-
-    try {
-      await fetchQuestionBank([], {
-        difficulties: ["H"],
-        domains: ["SEC"],
-        skills: ["BOU", "FSS"],
-      });
-      expect(requested).toContain("difficulties=H");
-      expect(requested).toContain("domains=SEC");
-      expect(requested).toContain("skills=BOU%2CFSS");
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  test("derives domain filters from selected skill filters", async () => {
-    const originalFetch = globalThis.fetch;
-    let requested = "";
-    globalThis.fetch = ((input: RequestInfo | URL) => {
-      requested = String(input);
-      return Promise.resolve(
-        new Response(JSON.stringify({ success: true, data: [] }), {
-          status: 200,
-          headers: { "content-type": "application/json" },
-        }),
-      );
-    }) as typeof fetch;
-
-    try {
-      await fetchQuestionBank([], {
-        difficulties: ["H"],
-        domains: ["INI"],
-        skills: ["WIC"],
-      });
-      expect(requested).toContain("domains=CAS");
-      expect(requested).toContain("skills=WIC");
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-});

package/test/focus.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { focusRows, toggleFocusRow } from "../src/focus.ts";
-import { focusGrid, moveFocusGridPosition, toggleFocusGridRow } from "../src/tui/focus-grid.ts";
-import type { Focus } from "../src/types.ts";
-
-describe("focus", () => {
-  test("renders skills as nested domain children", () => {
-    const rows = focusRows({ difficulties: ["H"], domains: ["CAS"], skills: ["WIC"] });
-    const cas = rows.find((row) => row.kind === "option" && row.value === "CAS");
-    const wic = rows.find((row) => row.kind === "option" && row.value === "WIC");
-
-    expect(cas).toMatchObject({ kind: "option", checked: true, partial: true, depth: 0 });
-    expect(wic).toMatchObject({ kind: "option", checked: true, depth: 1 });
-  });
-
-  test("domain toggles operate on their child skills", () => {
-    const focus: Focus = { difficulties: ["H"], domains: ["CAS"], skills: ["WIC"] };
-    const cas = focusRows(focus).find((row) => row.kind === "option" && row.value === "CAS");
-
-    expect(toggleFocusRow(focus, cas)).toEqual({
-      difficulties: ["H"],
-      domains: ["CAS"],
-      skills: ["WIC", "TSP", "CTC"],
-    });
-  });
-
-  test("grid navigation moves predictably across columns and rows", () => {
-    const focus: Focus = { difficulties: ["H"], domains: ["CAS"], skills: ["WIC"] };
-    const columns = focusGrid(focus);
-
-    expect(moveFocusGridPosition(columns, { column: 0, row: 1 }, "down")).toEqual({ column: 0, row: 2 });
-    expect(moveFocusGridPosition(columns, { column: 0, row: 2 }, "down")).toEqual({ column: 0, row: 2 });
-    expect(moveFocusGridPosition(columns, { column: 0, row: 2 }, "next")).toEqual({ column: 1, row: 2 });
-    expect(moveFocusGridPosition(columns, { column: 0, row: 2 }, "previous")).toEqual({ column: 4, row: 2 });
-  });
-
-  test("grid navigation clamps row when moving into shorter columns", () => {
-    const focus: Focus = { difficulties: ["H"], domains: ["INI"], skills: ["CID", "INF", "COE"] };
-    const columns = focusGrid(focus);
-
-    expect(moveFocusGridPosition(columns, { column: 1, row: 3 }, "next")).toEqual({ column: 2, row: 3 });
-    expect(moveFocusGridPosition(columns, { column: 2, row: 3 }, "next")).toEqual({ column: 3, row: 2 });
-  });
-
-  test("grid toggles use focus constraints", () => {
-    const focus: Focus = { difficulties: ["H"], domains: ["CAS"], skills: ["WIC"] };
-
-    expect(toggleFocusGridRow(focus, { column: 0, row: 2 })).toBe(focus);
-    expect(toggleFocusGridRow(focus, { column: 2, row: 0 })).toEqual({
-      difficulties: ["H"],
-      domains: ["CAS"],
-      skills: ["WIC", "TSP", "CTC"],
-    });
-  });
-});

package/test/state.test.ts

@@ -1,167 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { defaultFocus, normalizeFocus } from "../src/focus.ts";
-import {
-  buildSummaryRows,
-  displayStateDir,
-  loadAttempts,
-  loadFocus,
-  nextOutcome,
-  recordAttempt,
-  resolveStateDir,
-  saveAttempts,
-  saveFocus,
-  stateDirExists,
-} from "../src/state.ts";
-
-describe("state", () => {
-  test("resolves state dir under the user home directory", () => {
-    expect(resolveStateDir("/home/user")).toBe("/home/user/.saterminal/userlocal");
-  });
-
-  test("displays state dir with a tilde prefix", () => {
-    expect(displayStateDir("/home/user/.saterminal/userlocal", "/home/user")).toBe("~/.saterminal/userlocal");
-    expect(displayStateDir("/home/user", "/home/user")).toBe("~");
-  });
-
-  test("detects whether the state directory exists", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-
-    try {
-      expect(await stateDirExists(dir)).toBe(true);
-      expect(await stateDirExists(join(dir, "missing"))).toBe(false);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("creates and reads a compact attempts csv", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "attempts.csv");
-
-    try {
-      const attempts = await loadAttempts(path);
-      recordAttempt(attempts, "abc12345", false, 42, new Date("2026-01-01T00:00:00.000Z"));
-      await saveAttempts(attempts, path);
-
-      const raw = await readFile(path, "utf8");
-      expect(raw).toBe(
-        "question_id,outcome,updated_at,elapsed_seconds\nabc12345,incorrect,2026-01-01T00:00:00.000Z,42\n",
-      );
-      expect(await loadAttempts(path)).toEqual(attempts);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("uses corrected for a later right answer after a miss", () => {
-    const attempts = new Map();
-    recordAttempt(attempts, "abc12345", false, 12, new Date("2026-01-01T00:00:00.000Z"));
-    recordAttempt(attempts, "abc12345", true, 10, new Date("2026-01-02T00:00:00.000Z"));
-
-    expect(attempts.get("abc12345")?.outcome).toBe("corrected");
-  });
-
-  test("loads escaped csv fields", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "attempts.csv");
-
-    try {
-      await writeFile(
-        path,
-        "question_id,outcome,updated_at,elapsed_seconds\n\"abc,123\",correct,\"2026-01-01T00:00:00.000Z\",12\n",
-        "utf8",
-      );
-
-      expect(await loadAttempts(path)).toEqual(new Map([
-        ["abc,123", {
-          question_id: "abc,123",
-          outcome: "correct",
-          updated_at: "2026-01-01T00:00:00.000Z",
-          elapsed_seconds: 12,
-        }],
-      ]));
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("does not downgrade mastered outcomes", () => {
-    expect(nextOutcome("correct", false)).toBe("correct");
-    expect(nextOutcome("corrected", false)).toBe("corrected");
-  });
-
-  test("builds summary rows from attempts", () => {
-    const attempts = new Map();
-    recordAttempt(attempts, "a", true, 20, new Date("2026-01-01T00:00:00.000Z"));
-    recordAttempt(attempts, "b", false, 10, new Date("2026-01-01T00:00:00.000Z"));
-    recordAttempt(attempts, "b", true, 40, new Date("2026-01-02T00:00:00.000Z"));
-
-    const rows = buildSummaryRows(attempts, new Date("2026-01-03T00:00:00.000Z"));
-    expect(Object.fromEntries(rows.map((row) => [row.metric, row.value]))).toEqual({
-      answered: "2",
-      correct: "1",
-      incorrect: "0",
-      corrected: "1",
-      accuracy: "1.00",
-      avg_seconds: "30.0",
-    });
-  });
-
-  test("normalizes invalid focus selections to valid defaults", () => {
-    expect(normalizeFocus({ difficulties: [], domains: ["NOPE"], skills: ["CID"] })).toEqual({
-      difficulties: defaultFocus.difficulties,
-      domains: ["INI"],
-      skills: ["CID"],
-    });
-  });
-
-  test("derives focus domains from selected skills", () => {
-    expect(normalizeFocus({ difficulties: ["H"], domains: ["INI"], skills: ["WIC"] })).toEqual({
-      difficulties: ["H"],
-      domains: ["CAS"],
-      skills: ["WIC"],
-    });
-  });
-
-  test("creates default focus when file is missing", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "focus.json");
-
-    try {
-      expect(await loadFocus(path)).toEqual(defaultFocus);
-      expect(await readFile(path, "utf8")).toContain("\"difficulties\"");
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("saves and loads focus json", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "focus.json");
-
-    try {
-      await saveFocus({ difficulties: ["H"], domains: ["SEC"], skills: ["BOU", "FSS"] }, path);
-      expect(await loadFocus(path)).toEqual({ difficulties: ["H"], domains: ["SEC"], skills: ["BOU", "FSS"] });
-
-      await writeFile(path, "{\"difficulties\":[],\"domains\":[],\"skills\":[]}", "utf8");
-      expect(await loadFocus(path)).toEqual(defaultFocus);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("throws when focus json is invalid", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "focus.json");
-
-    try {
-      await writeFile(path, "{not json", "utf8");
-      await expect(loadFocus(path)).rejects.toThrow(/Invalid focus file/);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-});

package/test/text.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { hasHtmlTable, htmlToText, parseHtmlSegments, wrapSegments, wrapText } from "../src/text.ts";
-
-describe("text", () => {
-  test("converts the API html subset into terminal text", () => {
-    expect(htmlToText("<p><strong>Text 1</strong></p><p>Alice&rsquo;s claim&mdash;briefly.</p>")).toBe(
-      "Text 1\nAlice's claim-briefly.",
-    );
-  });
-
-  test("uses media labels instead of leaking svg internals", () => {
-    expect(
-      htmlToText(
-        '<figure><svg aria-label="Line graph titled Exports"><text>90807060</text></svg></figure><p>Read the graph.</p>',
-      ),
-    ).toBe("[Graph: Line graph titled Exports]\nRead the graph.");
-  });
-
-  test("keeps image alt text visible", () => {
-    expect(htmlToText('<p><img alt="Triangle ABC" src="/triangle.png"></p>')).toBe("[Image: Triangle ABC]");
-  });
-
-  test("detects html tables", () => {
-    expect(hasHtmlTable("<p>Text</p>", "<table><tr><td>1</td></tr></table>")).toBe(true);
-    expect(hasHtmlTable("<p>Text</p>")).toBe(false);
-  });
-
-  test("normalizes SAT blank markers", () => {
-    expect(htmlToText("<p>The answer is ______blank because of the data.</p>")).toBe(
-      "The answer is _______ because of the data.",
-    );
-  });
-
-  test("wraps text without dropping words", () => {
-    expect(wrapText("one two three four", 8)).toEqual(["one two", "three", "four"]);
-  });
-
-  test("preserves underline segments from u tags", () => {
-    const segments = parseHtmlSegments("<p>Before <u>underlined claim</u> after.</p>");
-    expect(segments.some((segment) => segment.style.underline && segment.text.includes("underlined claim"))).toBe(true);
-    expect(htmlToText("<p>Before <u>underlined claim</u> after.</p>")).toBe("Before underlined claim after.");
-  });
-
-  test("normalizes API blank spans in parsed segments", () => {
-    const html =
-      '<p>The answer is <span aria-hidden="true">______</span><span class="sr-only">blank</span> because of the data.</p>';
-    const text = parseHtmlSegments(html)
-      .map((segment) => segment.text)
-      .join("")
-      .trim();
-    expect(text).toBe("The answer is _______ because of the data.");
-  });
-
-  test("wraps styled segments without losing underline spans", () => {
-    const segments = parseHtmlSegments("<u>This insightful depiction of a preteen girl</u>");
-    const lines = wrapSegments(segments, 20);
-    expect(lines.flat().some((segment) => segment.style.underline)).toBe(true);
-  });
-
-  test("collapses spacer paragraphs and decodes accented entities in dual-text stimuli", () => {
-    const html = `<p><strong><span role="heading">Text 1</span></strong></p>
-<p>the object that struck the Yucat&aacute;n Peninsula</p>
-<p>&nbsp;</p>
-<p><strong><span role="heading">Text 2</span></strong></p>
-<p>Artemieva argues that an asteroid is plausible.</p>`;
-    const lines = wrapSegments(parseHtmlSegments(html), 40).map((line) => line.map((segment) => segment.text).join(""));
-    const blankLines = lines.filter((line) => !line.trim()).length;
-    expect(blankLines).toBeLessThanOrEqual(2);
-    expect(lines.join("\n")).toContain("Yucatán");
-    expect(lines.join("\n")).not.toContain("&aacute;");
-  });
-});

package/test/viewport.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  clampScroll,
-  ensureRangeVisible,
-  ensureRowVisible,
-  maxScroll,
-  scrollBy,
-  scrollPage,
-  scrollToEdge,
-} from "../src/tui/viewport.ts";
-
-describe("viewport", () => {
-  test("clamps scroll to the available content", () => {
-    expect(maxScroll({ scroll: 0, height: 5, contentRows: 12 })).toBe(7);
-    expect(clampScroll({ scroll: -3, height: 5, contentRows: 12 })).toBe(0);
-    expect(clampScroll({ scroll: 20, height: 5, contentRows: 12 })).toBe(7);
-    expect(clampScroll({ scroll: 20, height: 5, contentRows: 3 })).toBe(0);
-  });
-
-  test("scrolls by lines and pages", () => {
-    const viewport = { scroll: 4, height: 5, contentRows: 20 };
-
-    expect(scrollBy(viewport, 2)).toBe(6);
-    expect(scrollBy(viewport, -10)).toBe(0);
-    expect(scrollPage(viewport, 1)).toBe(8);
-    expect(scrollPage(viewport, -1)).toBe(0);
-    expect(scrollToEdge(viewport, "bottom")).toBe(15);
-  });
-
-  test("keeps a selected row or wrapped range visible", () => {
-    const viewport = { scroll: 4, height: 5, contentRows: 20 };
-
-    expect(ensureRowVisible(viewport, 3)).toBe(3);
-    expect(ensureRowVisible(viewport, 8)).toBe(4);
-    expect(ensureRowVisible(viewport, 12)).toBe(8);
-    expect(ensureRangeVisible(viewport, 11, 13)).toBe(9);
-    expect(ensureRangeVisible(viewport, 5, 7)).toBe(4);
-  });
-});

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "strict": true,
-    "skipLibCheck": true,
-    "types": ["bun"],
-    "allowImportingTsExtensions": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*.ts", "src/**/*.d.ts", "test/**/*.ts"]
-}