learn-loops 0.4.3 → 0.4.5

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/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";
@@ -19,9 +19,12 @@ 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
 
+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) {
@@ -102,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);
@@ -134,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));
@@ -216,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;
@@ -255,7 +272,7 @@ async function main() {
     }
     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/learn.js

@@ -184,9 +184,11 @@ async function teach(ctx) {
     }
     // 7. Think deeper: trade-offs, failure modes, second-order effects.
     if (ctx.deep) {
-        const rounds = await thinkDeeper(profile, topic.state, ctx.title, lesson.deeper);
-        if (rounds.length)
-            extras.deeper = rounds;
+        if (lesson.deeper) {
+            const rounds = await thinkDeeper(profile, topic.state, ctx.title, lesson.deeper);
+            if (rounds.length)
+                extras.deeper = rounds;
+        }
         // 8. Personal connection.
         const conn = must(await p.text({ message: `${t.pink("Where could you use this?")}`, placeholder: "a project, a decision, something you've seen (blank to skip)" })).trim();
         if (conn) {

package/dist/flows/think.js

@@ -12,7 +12,7 @@ function showCritique(c) {
  * Trade-offs, failure modes, scale and second-order effects. Round one uses the lesson's own question;
  * further rounds rotate through different lenses so the learner practises seeing a topic from many sides.
  */
-export async function thinkDeeper(profile, s, title, seed, maxRounds = 3) {
+export async function thinkDeeper(profile, s, title, seed, maxRounds = 2) {
     const rounds = [];
     let lensIdx = Math.floor(Math.random() * LENSES.length);
     let current = seed ? { lens: "Think deeper", ...seed } : undefined;

package/dist/prompts.js

@@ -54,7 +54,7 @@ Rules: max ~250 words in markdown. ${p.order === "examples-first" ? "Open with a
 Use the learner's preferred styles (${p.styles.join(", ") || "any"}). ${diagramRule(p)} ${MERMAID_RULES}
 ${STEM_RULES}
 ${QUESTION_RULES}
-Exactly 2 multiple-choice checks (4 options each, "answer" is the 0-based index, plausible distractors based on real misconceptions; vary the position of the right answer). 2-3 flashcards.
+Exactly 3 multiple-choice checks (4 options each, "answer" is the 0-based index, plausible distractors based on real misconceptions; vary the position of the right answer) in rising difficulty: 1 easy (recall the core idea), 1 medium (apply it to a simple case), 1 hard (a subtle case or a common misconception). Order them easy to hard. 2-3 flashcards.
 Return ONLY JSON of this shape:
 ${lessonShape}`;
 }
@@ -72,9 +72,9 @@ Rules: 400-650 words of markdown with ## subheadings. ${p.order === "examples-fi
 Include a worked example, one common misconception to avoid, and ${p.diagrams === "minimal" ? "at least one" : "1-2"} figure(s) (mermaid, svg or plot as fits the subject) showing the real mechanism/structure (not decoration). ${MERMAID_RULES}
 ${STEM_RULES}
 ${QUESTION_RULES}
-Challenge level: ${p.challenge}. Exactly ${p.challenge === "tough" ? 4 : 3} multiple-choice checks that test understanding/application, not trivia (4 options, "answer" is 0-based). 3-4 flashcards phrased as recall questions.
+Challenge level: ${p.challenge}. Exactly ${p.challenge === "tough" ? 5 : p.challenge === "gentle" ? 3 : 4} multiple-choice checks that test understanding/application, not trivia (4 options, "answer" is 0-based), ordered easy to hard: at least one easy recall check, mostly medium application checks, and at least one hard check (subtle case or misconception). 3-4 flashcards phrased as recall questions.
 ${p.socratic ? "The learner prefers a SOCRATIC style: the markdown is the consolidation shown AFTER they work through your leading questions, so it should name and tie together the ideas those questions lead to." : ""}
-Also include the "prediction" (a situation where a wrong intuition is likely, so they learn from guessing wrong), the "deeper" trade-off question${p.socratic ? ", and exactly 3 \"socratic\" questions" : ""}.
+Also include the "prediction" (a situation where a wrong intuition is likely, so they learn from guessing wrong). Include the "deeper" trade-off question ONLY if this lesson has a genuine judgement call, trade-off or failure mode worth debating; for foundational or purely procedural lessons set "deeper" to null (roughly half of lessons should have none)${p.socratic ? ", and exactly 3 \"socratic\" questions" : ""}.
 Return ONLY JSON of this shape (omit the /* */ comment):
 ${lessonShapeBase}${deepExtras(!!p.socratic)}`;
 }
@@ -150,6 +150,7 @@ export function critiquePrompt(p, title, question, considerations, answer) {
 A thoughtful answer would raise: ${considerations.map((c) => `- ${c}`).join("\n")}
 Learner's answer: """${answer}"""
 Judge reasoning quality, not length: did they weigh both sides, name concrete risks, and notice second-order effects? Credit valid points that are NOT in the list. Be ${tone}.
+Be proportionate, not pedantic: list at most 2 blind spots and only ones that would change their conclusion; skip nitpicks, wording quibbles and edge cases that don't matter. If the answer is solid, say so and leave "blindSpots" empty and "pushback" an empty string.
 Return ONLY JSON: {"strong":["good points they made"],"blindSpots":["important angles they did not consider, each with one sentence of why it matters"],"pushback":"one hard follow-up that challenges their weakest assumption","feedback":"2 sentences"}`;
 }
 export function challengePrompt(p, s, area, covered) {

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.3",
+  "version": "0.4.5",
   "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",