learn-loops 0.4.2 → 0.4.4

package/README.md

@@ -7,7 +7,7 @@ npm i -g learn-loops
 loops
 ```
 
-Requires Node 20+ and either the `claude` or `codex` CLI installed and logged in. If `loops` isn't found after install, add npm's global bin folder to your `PATH` (`npm prefix -g`, then `<that>/bin`).
+Requires Node 20+ and either the `claude` or `codex` CLI installed and logged in (`npm i -g @anthropic-ai/claude-code` or `npm i -g @openai/codex`). If neither is found, `loops` says so and shows how to install one; if your saved tutor is missing but the other is present, it falls back to that one. If `loops` isn't found after install, add npm's global bin folder to your `PATH` (`npm prefix -g`, then `<that>/bin`).
 
 ## How it teaches
 
@@ -61,4 +61,10 @@ loops profile       edit your learner profile
 ```
 
 Your profile and streak live in `~/.config/loops/`.
-Env: `LOOPS_HOME`, `LOOPS_PROVIDER=claude|codex`, `LOOPS_IMAGES`, `NO_COLOR`.
+### Billing safety
+
+`loops` runs the CLIs under your subscription login and strips `ANTHROPIC_API_KEY`, `OPENAI_API_KEY` and similar variables from their environment, so you aren't billed per token by accident. A CLI signed in with an API key (or Bedrock/Vertex) is refused unless you set `LOOPS_ALLOW_API_BILLING=1`. If your tutor fails (usage limit, outage), `loops` automatically tries the other one.
+
+It **can't** see your account's "extra usage" (Claude) or credits (ChatGPT/Codex) settings, because neither CLI exposes them. If you don't want overage charges, turn those off in your account settings.
+
+Env: `LOOPS_HOME`, `LOOPS_PROVIDER=claude|codex`, `LOOPS_ALLOW_API_BILLING=1`, `LOOPS_IMAGES`, `NO_COLOR`.

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import * as p from "@clack/prompts";
-import { listTopics, loadProfile, configDir } from "./store.js";
+import { listTopics, loadProfile, configDir, deleteTopic } from "./store.js";
+import { PROVIDER_HELP, allStatuses, noProviderMessage, setNotifier } from "./llm.js";
 import { isDue } from "./srs.js";
 import { currentStreak, doneToday, loadStats, recordActivity, saveCheckin } from "./stats.js";
 import { banner, bar, must, t } from "./ui.js";
@@ -18,10 +19,13 @@ const HELP = `${t.bold("loops")} — learn anything with Claude Code or Codex as
   loops streak          your streak
   loops map             show a topic's map and prerequisite diagram
   loops topics          list your topics and progress
+  loops delete          delete a topic and all its notes and progress
   loops profile         edit how you like to learn
   loops --help          this help
 
-Env: LOOPS_HOME (config dir), LOOPS_PROVIDER=claude|codex, NO_COLOR`;
+To delete a course: run ${t.bold("loops delete")}, or choose "Delete a topic" from the menu.
+
+Env: LOOPS_HOME (config dir), LOOPS_PROVIDER=claude|codex, LOOPS_ALLOW_API_BILLING=1 (allow pay-per-token logins), NO_COLOR`;
 const dueCount = (topics) => topics.reduce((n, tp) => n + tp.state.cards.filter((c) => isDue(c)).length, 0);
 function progressOf(tp) {
     const areas = tp.state.map?.areas ?? [];
@@ -101,12 +105,15 @@ async function startScreen(profile, topics, rec) {
             }),
             { value: "__new", label: t.accent("+ Start something new") },
             { value: "__menu", label: t.dim("Go to the main menu") },
+            { value: "__delete", label: t.dim("Delete a topic"), hint: "or run `loops delete`" },
         ],
     }));
     if (choice === "__menu")
         return;
     if (choice === "__new")
         return dispatch("new", profile);
+    if (choice === "__delete")
+        return dispatch("delete", profile);
     const tp = recent[Number(choice)];
     if (tp.state.map && tp.state.phase === "survey" && !tp.state.progress[tp.state.map.areas[0].id]?.surveyed)
         printMap(tp);
@@ -133,7 +140,7 @@ async function menu(profile) {
             ...(due ? [{ value: "review", label: "Review flashcards", hint: `${due} due${star("review")}` }] : []),
             ...(cards >= 4 ? [{ value: "quiz", label: "Mixed quiz", hint: `interleaved, weakest first${star("quiz")}` }] : []),
             ...(topics.some((tp) => tp.state.mistakes?.length) ? [{ value: "mistakes", label: "Mistake journal" }] : []),
-            ...(topics.length ? [{ value: "topics", label: "My topics" }] : []),
+            ...(topics.length ? [{ value: "topics", label: "My topics" }, { value: "delete", label: "Delete a topic" }] : []),
         ];
         // put the recommendation first
         opts.sort((a, b) => Number(b.value === rec) - Number(a.value === rec));
@@ -215,6 +222,17 @@ async function dispatch(action, profile, arg) {
                 printMap(tp);
             break;
         }
+        case "delete": {
+            if (!topics.length)
+                return p.log.warn("No topics to delete.");
+            const tp = arg ? topics.find((x) => x.state.title.toLowerCase() === arg.toLowerCase()) ?? (await chooseTopic(topics, "Which topic?")) : await chooseTopic(topics, "Which topic do you want to delete?");
+            const ok = must(await p.confirm({ message: `Delete "${tp.state.title}" and all its notes, cards and progress? This can't be undone.`, initialValue: false }));
+            if (!ok)
+                return p.log.info("Kept it.");
+            await deleteTopic(tp);
+            p.log.success(t.ok(`Deleted "${tp.state.title}".`));
+            break;
+        }
         case "profile":
             await onboard(profile);
             break;
@@ -231,14 +249,30 @@ async function main() {
         process.exit(1);
     }
     banner();
+    setNotifier((m) => p.log.warn(m));
+    const statuses = await allStatuses();
+    const usable = statuses.filter((x) => x.usable);
+    if (!usable.length) {
+        const installed = statuses.filter((x) => x.installed);
+        p.log.error(t.bad(installed.length ? `No usable tutor:\n${installed.map((x) => `  - ${x.reason}`).join("\n")}` : noProviderMessage()));
+        process.exit(1);
+    }
+    for (const x of statuses)
+        if (x.installed && !x.usable)
+            p.log.warn(x.reason);
     let profile = await loadProfile();
     if (!profile)
         profile = await onboard();
     if (process.env.LOOPS_PROVIDER === "claude" || process.env.LOOPS_PROVIDER === "codex")
         profile.provider = process.env.LOOPS_PROVIDER;
+    if (!usable.some((x) => x.name === profile.provider)) {
+        const fallback = usable[0].name;
+        p.log.warn(`Using ${PROVIDER_HELP[fallback].label} for this session instead of ${PROVIDER_HELP[profile.provider].label}.`);
+        profile.provider = fallback;
+    }
     if (!cmd)
         return menu(profile);
-    if (["new", "continue", "review", "quiz", "mistakes", "streak", "topics", "profile", "map"].includes(cmd))
+    if (["new", "continue", "review", "quiz", "mistakes", "streak", "topics", "profile", "map", "delete"].includes(cmd))
         return dispatch(cmd, profile, rest.join(" ") || undefined);
     console.log(HELP);
     process.exit(1);

package/dist/flows/onboard.js

@@ -1,25 +1,28 @@
 import * as p from "@clack/prompts";
-import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { PROVIDER_HELP, hasBinary as has, installedProviders } from "../llm.js";
 import { saveProfile } from "../store.js";
 import { must, t } from "../ui.js";
-const has = (bin) => {
-    try {
-        execFileSync("which", [bin], { stdio: "ignore" });
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
 export async function onboard(existing) {
     p.intro(t.bold(t.accent(existing ? " Edit your learner profile " : " Let's set up how YOU learn ")));
-    if (!existing)
+    if (!existing) {
         p.note("Answer a few questions so every lesson, quiz and diagram fits you.\nYou can change any of this later with `loops profile`.", "Welcome");
+        const found = ["claude", "codex"].map((n) => `${has(n) ? t.ok("✓") : t.dim("✗")} ${PROVIDER_HELP[n].label}`).join("   ");
+        p.note([
+            `loops has no AI of its own. It looks for Claude Code or Codex on your computer and uses it as your tutor:  ${found}`,
+            "",
+            "To avoid surprise charges:",
+            "  • It only uses your subscription login. API-key / pay-per-token logins are refused,",
+            "    and API-key environment variables are hidden from the tutor.",
+            "  • If one tutor fails (e.g. usage limit), it switches to the other.",
+            "  • It can't see your account's \"extra usage\" / credits setting. Turn that off in your",
+            "    Claude or ChatGPT account settings if you don't want to pay beyond your plan.",
+        ].join("\n"), "Your tutor & billing");
+    }
     const d = existing;
     const name = must(await p.text({ message: "What should I call you?", initialValue: d?.name, validate: (v) => (v?.trim() ? undefined : "Required") }));
-    const installed = ["claude", "codex"].filter(has);
+    const installed = installedProviders();
     const provider = must(await p.select({
         message: "Which AI tutor should power your lessons?",
         initialValue: d?.provider ?? installed[0] ?? "claude",

package/dist/llm.js

@@ -1,16 +1,59 @@
 import { spawn } from "node:child_process";
+import { accessSync, constants } from "node:fs";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { delimiter, join } from "node:path";
 export const TUTOR_SYSTEM = [
     "You are an exceptional tutor grounded in learning science: you activate prior knowledge,",
     "teach in small chunks, use concrete examples and diagrams, test retrieval rather than recognition,",
     "and correct misconceptions precisely. You never pad. You are accurate: if unsure, say so.",
     "You output exactly what is asked for, in the requested format, with no preamble.",
 ].join(" ");
-function run(cmd, args, input, timeoutMs) {
+export const PROVIDER_HELP = {
+    claude: { label: "Claude Code", install: "npm install -g @anthropic-ai/claude-code", login: "claude" },
+    codex: { label: "Codex CLI", install: "npm install -g @openai/codex", login: "codex login" },
+};
+/** True if `bin` is an executable file in some PATH directory (honours PATHEXT on Windows). */
+export function hasBinary(bin, env = process.env) {
+    const exts = process.platform === "win32" ? ["", ...(env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";")] : [""];
+    for (const dir of (env.PATH ?? "").split(delimiter).filter(Boolean)) {
+        for (const ext of exts) {
+            try {
+                accessSync(join(dir, bin + ext), constants.X_OK);
+                return true;
+            }
+            catch { }
+        }
+    }
+    return false;
+}
+export const installedProviders = () => ["claude", "codex"].filter((n) => hasBinary(n));
+export function noProviderMessage() {
+    return [
+        "loops needs Claude Code or Codex installed to act as your tutor, and found neither on your PATH.",
+        "",
+        "Install one, sign in, then run loops again:",
+        ...Object.keys(PROVIDER_HELP).map((n) => `  ${PROVIDER_HELP[n].label}: ${PROVIDER_HELP[n].install}  (then: ${PROVIDER_HELP[n].login})`),
+        "",
+        "Already installed in a non-standard place? Add its folder to your PATH.",
+        "Sign in with a subscription account: loops refuses API-key / pay-per-token logins unless LOOPS_ALLOW_API_BILLING=1.",
+    ].join("\n");
+}
+/** Credentials that make a CLI bill per token instead of using the user's subscription login. */
+const METERED_ENV = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_USE_BEDROCK", "CLAUDE_CODE_USE_VERTEX", "CLAUDE_CODE_USE_FOUNDRY", "OPENAI_API_KEY", "CODEX_API_KEY"];
+export const allowMetered = (env = process.env) => env.LOOPS_ALLOW_API_BILLING === "1";
+/** The environment child CLIs run in: pay-per-token credentials are removed unless the user opted in. */
+export function childEnv(env = process.env) {
+    if (allowMetered(env))
+        return { ...env };
+    const out = { ...env };
+    for (const k of METERED_ENV)
+        delete out[k];
+    return out;
+}
+function run(cmd, args, input, timeoutMs, includeStderr = false) {
     return new Promise((resolve, reject) => {
-        const child = spawn(cmd, args, { cwd: tmpdir(), stdio: ["pipe", "pipe", "pipe"] });
+        const child = spawn(cmd, args, { cwd: tmpdir(), env: childEnv(), stdio: ["pipe", "pipe", "pipe"] });
         let out = "";
         let err = "";
         const timer = setTimeout(() => {
@@ -21,19 +64,20 @@ function run(cmd, args, input, timeoutMs) {
         child.stderr.on("data", (d) => (err += d));
         child.on("error", (e) => {
             clearTimeout(timer);
-            reject(new Error(`Could not run "${cmd}" — is it installed and on your PATH? (${e.message})`));
+            const help = PROVIDER_HELP[cmd];
+            reject(new Error(`Could not run "${cmd}" — is it installed and on your PATH?${help ? ` Install: ${help.install}` : ""} (${e.message})`));
         });
         child.on("close", (code) => {
             clearTimeout(timer);
             if (code === 0)
-                resolve(out);
+                resolve(includeStderr ? out + err : out);
             else
                 reject(new Error(`${cmd} exited with ${code}: ${err.trim().split("\n").slice(-4).join("\n")}`));
         });
         child.stdin.end(input);
     });
 }
-export async function complete(provider, prompt, timeoutMs = 240_000) {
+async function completeWith(provider, prompt, timeoutMs) {
     if (provider === "claude") {
         return run("claude", ["-p", "--tools", "", "--no-session-persistence", "--output-format", "text", "--system-prompt", TUTOR_SYSTEM], prompt, timeoutMs);
     }
@@ -47,6 +91,87 @@ export async function complete(provider, prompt, timeoutMs = 240_000) {
         await rm(dir, { recursive: true, force: true });
     }
 }
+/** Classify `claude auth status` JSON. Anything that isn't a first-party subscription login bills per token. */
+export function classifyClaude(raw) {
+    let j;
+    try {
+        j = JSON.parse(raw);
+    }
+    catch {
+        return "unknown";
+    }
+    if (j.loggedIn === false)
+        return "logged-out";
+    const method = String(j.authMethod ?? "");
+    if ((j.apiProvider && j.apiProvider !== "firstParty") || /api.?key|console/i.test(method))
+        return "metered";
+    return /claude\.ai|oauth|subscription/i.test(method) ? "subscription" : "unknown";
+}
+/** Classify `codex login status` output. */
+export function classifyCodex(text) {
+    if (/not logged in/i.test(text))
+        return "logged-out";
+    if (/api key/i.test(text))
+        return "metered";
+    return /chatgpt/i.test(text) ? "subscription" : "unknown";
+}
+async function probe(name) {
+    const label = PROVIDER_HELP[name].label;
+    const bad = (billing, reason) => ({ name, installed: hasBinary(name), billing, usable: false, reason });
+    if (!hasBinary(name))
+        return bad("unknown", `${label} isn't installed (${PROVIDER_HELP[name].install})`);
+    let billing;
+    try {
+        billing = name === "claude" ? classifyClaude(await run("claude", ["auth", "status"], "", 20_000)) : classifyCodex(await run("codex", ["login", "status"], "", 20_000, true));
+    }
+    catch {
+        billing = "logged-out";
+    }
+    if (billing === "logged-out")
+        return bad(billing, `${label} isn't signed in (run: ${PROVIDER_HELP[name].login})`);
+    if (billing === "metered" && !allowMetered()) {
+        return bad(billing, `${label} is signed in with an API key / pay-per-token account, which would charge you per request. Sign in with your subscription instead, or set LOOPS_ALLOW_API_BILLING=1 to allow it`);
+    }
+    return { name, installed: true, billing, usable: true, reason: "" };
+}
+const statusCache = new Map();
+export const providerStatus = (name) => {
+    if (!statusCache.has(name))
+        statusCache.set(name, probe(name));
+    return statusCache.get(name);
+};
+export const allStatuses = () => Promise.all(["claude", "codex"].map(providerStatus));
+let notify = (m) => console.error(m);
+export const setNotifier = (fn) => (notify = fn);
+let sticky;
+/**
+ * Run the prompt on the preferred tutor; if it can't be used or fails (usage limit, outage, signed out), fall back
+ * to the other one — but never to a CLI that would bill per token. Once a fallback works it's kept for the session.
+ */
+export async function complete(preferred, prompt, timeoutMs = 240_000) {
+    const first = sticky ?? preferred;
+    const order = [first, first === "claude" ? "codex" : "claude"];
+    const problems = [];
+    for (const name of order) {
+        const st = await providerStatus(name);
+        if (!st.usable) {
+            problems.push(st.reason);
+            continue;
+        }
+        if (name !== first)
+            notify(`${PROVIDER_HELP[order[0]].label} didn't work, so I'm trying ${PROVIDER_HELP[name].label} instead.`);
+        try {
+            const out = await completeWith(name, prompt, timeoutMs);
+            if (name !== preferred)
+                sticky = name;
+            return out;
+        }
+        catch (e) {
+            problems.push(`${PROVIDER_HELP[name].label}: ${e.message}`);
+        }
+    }
+    throw new Error(problems.join("\n"));
+}
 /**
  * Models often forget to double LaTeX backslashes inside JSON strings. `\theta` would silently parse as a
  * tab + "heta", `\nabla` as newline + "abla", `\frac` as form feed + "rac". Double the backslash of any

package/dist/store.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile, readdir } from "node:fs/promises";
+import { mkdir, readFile, writeFile, readdir, rm } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
@@ -54,6 +54,13 @@ export async function listTopics(profile) {
     return topics.sort((a, b) => lastTouched(b).localeCompare(lastTouched(a)));
 }
 const lastTouched = (t) => t.state.cards.map((c) => c.due).sort().pop() ?? t.state.createdAt;
+/** Removes a topic's folder (notes, cards, progress) and its category folder if that leaves it empty. */
+export async function deleteTopic(topic) {
+    await rm(topic.dir, { recursive: true, force: true });
+    const cat = dirname(topic.dir);
+    if (!(await readdir(cat).catch(() => ["x"])).length)
+        await rm(cat, { recursive: true, force: true });
+}
 export async function listCategories(profile) {
     const root = expandHome(profile.rootDir);
     if (!existsSync(root))

package/dist/table.js

@@ -0,0 +1,50 @@
+import Table from "cli-table3";
+export const isTableLine = (s) => /^\s*\|.*\|\s*$/.test(s);
+const ANSI = /\x1b\[[0-9;]*m/g;
+const visible = (s) => s.replace(ANSI, "").length;
+function splitRow(line) {
+    const body = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+    return body.split(/(?<!\\)\|/).map((c) => c.replace(/\\\|/g, "|").trim());
+}
+const alignOf = (c) => (/^:-+:$/.test(c) ? "center" : /^-+:$/.test(c) ? "right" : "left");
+/**
+ * Draw a markdown table (consecutive `| a | b |` lines) as a bordered, aligned box that wraps to maxWidth.
+ * `cell` styles a cell's text (e.g. inline bold/code/math); `head` styles header cells.
+ */
+export function renderTable(lines, cell, head, border, maxWidth) {
+    const rows = lines.map(splitRow);
+    const hasHeader = rows.length > 1 && rows[1].every((c) => /^:?-+:?$/.test(c));
+    const aligns = hasHeader ? rows[1].map(alignOf) : [];
+    const data = hasHeader ? [rows[0], ...rows.slice(2)] : rows;
+    const n = Math.max(...data.map((r) => r.length));
+    const grid = data.map((r, i) => Array.from({ length: n }, (_, c) => (hasHeader && i === 0 ? head : cell)(r[c] ?? "")));
+    const widths = Array.from({ length: n }, (_, c) => Math.max(1, ...grid.map((r) => Math.max(...r[c].split("\n").map(visible)))));
+    const budget = maxWidth - (3 * n + 1);
+    if (budget < 5 * n)
+        return stacked(data, hasHeader, cell, head);
+    while (widths.reduce((a, b) => a + b, 0) > budget)
+        widths[widths.indexOf(Math.max(...widths))]--;
+    const table = new Table({
+        chars: { top: "─", "top-mid": "┬", "top-left": "╭", "top-right": "╮", bottom: "─", "bottom-mid": "┴", "bottom-left": "╰", "bottom-right": "╯", left: "│", "left-mid": "├", mid: "─", "mid-mid": "┼", right: "│", "right-mid": "┤", middle: "│" },
+        style: { head: [], border: [], "padding-left": 1, "padding-right": 1 },
+        colWidths: widths.map((w) => w + 2),
+        colAligns: Array.from({ length: n }, (_, c) => aligns[c] ?? "left"),
+        wordWrap: true,
+    });
+    grid.forEach((r) => table.push(r));
+    let drawn = table.toString().split("\n");
+    // keep the rule under the header; drop the ones between single-line rows (they only add noise)
+    const wrapped = drawn.length - (grid.length * 2 + 1) > 0;
+    if (!wrapped)
+        drawn = drawn.filter((l, i) => !l.startsWith("├") || i === drawn.findIndex((x) => x.startsWith("├")));
+    return drawn.map((l) => l.replace(/[─│╭╮╰╯├┤┬┴┼]+/g, border));
+}
+/** Fallback for terminals too narrow for a grid: one "header: value" block per row. */
+function stacked(data, hasHeader, cell, head) {
+    const out = [];
+    const keys = hasHeader ? data[0] : [];
+    for (const r of hasHeader ? data.slice(1) : data) {
+        out.push(...r.map((v, c) => (keys[c] ? `${head(keys[c])}: ${cell(v)}` : cell(v))), "");
+    }
+    return out.slice(0, -1);
+}

package/dist/ui.js

@@ -3,6 +3,7 @@ import pc from "picocolors";
 import { renderDiagram } from "./diagram.js";
 import { parsePlot, plotToBraille, renderPlot, sanitizeSvg, svgCaption } from "./figures.js";
 import { mathToText, svgToPng, texToLines, texToPng } from "./math.js";
+import { isTableLine, renderTable } from "./table.js";
 import { drawImage, imageProtocol } from "./termimg.js";
 const useColor = !!process.stdout.isTTY && !process.env.NO_COLOR;
 const c256 = (n) => (s) => (useColor ? `\x1b[38;5;${n}m${s}\x1b[39m` : s);
@@ -112,7 +113,15 @@ export function renderMd(md) {
         .replace(/\*\*(.+?)\*\*/g, (_, x) => t.bold(x))
         .replace(/`([^`]+)`/g, (_, x) => t.cyan(x))
         .replace(/(?<![*\w])\*([^*]+)\*(?!\w)/g, (_, x) => t.italic(x));
+    let tableBuf = [];
+    const flushTable = () => {
+        const cols = process.stdout.columns ?? 100;
+        out.push(...renderTable(tableBuf, inline, (x) => t.bold(t.accent(inline(x))), t.dim, cols - 4).map((l) => "  " + l));
+        tableBuf = [];
+    };
     for (const raw of md.split("\n")) {
+        if (tableBuf.length && !isTableLine(raw))
+            flushTable();
         // display math: $$ … $$ (one or many lines) and \[ … \]
         if (math) {
             const close = raw.match(/^(.*?)(\$\$|\\\])\s*$/);
@@ -162,6 +171,10 @@ export function renderMd(md) {
             out.push("  " + t.dim("│ ") + t.cyan(raw));
             continue;
         }
+        if (isTableLine(raw)) {
+            tableBuf.push(raw);
+            continue;
+        }
         const h = raw.match(/^(#{1,4})\s+(.*)/);
         if (h) {
             out.push("", "  " + (h[1].length <= 2 ? t.bold(t.accent(inline(h[2]))) : t.bold(inline(h[2]))));
@@ -179,6 +192,8 @@ export function renderMd(md) {
         }
         out.push(raw.trim() ? "  " + inline(raw) : "");
     }
+    if (tableBuf.length)
+        flushTable();
     return out.join("\n");
 }
 /** Plain-text math for prompts, options and flashcards. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "learn-loops",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "A learning CLI that uses Claude Code / Codex as your tutor",
   "type": "module",
   "bin": {
@@ -21,6 +21,7 @@
     "@clack/prompts": "^1.8.1",
     "@resvg/resvg-js": "^2.6.2",
     "beautiful-mermaid": "^1.1.3",
+    "cli-table3": "^0.6.5",
     "mathjax-full": "^3.2.1",
     "mathjs": "^15.2.0",
     "picocolors": "^1.1.1",