sunnah 1.1.4 → 1.2.1

package/bin/index.js

@@ -3,6 +3,7 @@
 import { fileURLToPath } from "url";
 import path from "path";
 import fs from "fs";
+import os from "os";
 import { execSync, spawn } from "child_process";
 import readline from "readline";
 
@@ -16,6 +17,28 @@ const pkg = JSON.parse(
 const isWin = process.platform === "win32";
 const NPM = isWin ? "npm.cmd" : "npm";
 
+// ── Persistence: remember last selections ────────────────────────────────────
+const STATE_FILE = path.join(os.homedir(), ".sunnah-state.json");
+
+function loadPersistedState() {
+  try {
+    const raw = fs.readFileSync(STATE_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+function savePersistedState(data) {
+  try {
+    const existing = loadPersistedState();
+    fs.writeFileSync(
+      STATE_FILE,
+      JSON.stringify({ ...existing, ...data }, null, 2),
+    );
+  } catch {}
+}
+
 // ── Colors ────────────────────────────────────────────────────────────────────
 const c = {
   reset: "\x1b[0m",
@@ -41,6 +64,7 @@ const gray = (t) => clr(c.gray, t);
 const red = (t) => clr(c.red, t);
 const dim = (t) => clr(c.dim, t);
 const white = (t) => clr(c.white, t);
+const blue = (t) => clr(c.blue, t);
 
 // ── Available packages ────────────────────────────────────────────────────────
 const PACKAGES = [
@@ -51,6 +75,7 @@ const PACKAGES = [
     desc: "The most authentic collection of hadith, widely regarded as the most sahih after the Quran.",
     hadiths: "7,563",
     cmd: "bukhari",
+    hook: "useBukhari",
   },
   {
     name: "sahih-muslim",
@@ -59,6 +84,7 @@ const PACKAGES = [
     desc: "Second most authentic hadith collection, known for its strict methodology and chain verification.",
     hadiths: "7,470",
     cmd: "muslim",
+    hook: "useMuslim",
   },
   {
     name: "sunan-abi-dawud",
@@ -67,6 +93,7 @@ const PACKAGES = [
     desc: "One of the six canonical hadith collections, focused on legal rulings and jurisprudence.",
     hadiths: "5,274",
     cmd: "dawud",
+    hook: "useDawud",
   },
   {
     name: "jami-al-tirmidhi",
@@ -75,29 +102,47 @@ const PACKAGES = [
     desc: "Part of the six major hadith collections, unique for grading each hadith's authenticity.",
     hadiths: "3,956",
     cmd: "tirmidhi",
+    hook: "useTirmidhi",
   },
 ];
 
-// ── Terminal helpers ──────────────────────────────────────────────────────────
+// cmd → package lookup
+const CMD_MAP = Object.fromEntries(PACKAGES.map((p) => [p.cmd, p]));
+
+// ── Terminal: alternate screen buffer = no scroll ─────────────────────────────
 const W = () => process.stdout.columns || 80;
+const H = () => process.stdout.rows || 24;
 
-function clearLine() {
-  process.stdout.write("\r\x1b[K");
+function enterAltScreen() {
+  process.stdout.write("\x1b[?1049h");
 }
-
-function moveUp(n) {
-  if (n > 0) process.stdout.write(`\x1b[${n}A`);
+function leaveAltScreen() {
+  process.stdout.write("\x1b[?1049l");
+}
+function clearScreen() {
+  process.stdout.write("\x1b[2J\x1b[H");
+}
+function moveTo(r, col) {
+  process.stdout.write(`\x1b[${r};${col}H`);
 }
-
 function hideCursor() {
   process.stdout.write("\x1b[?25l");
 }
 function showCursor() {
   process.stdout.write("\x1b[?25h");
 }
+function clearToEOL() {
+  process.stdout.write("\x1b[K");
+}
+
+function writeLine(row, text) {
+  moveTo(row, 1);
+  clearToEOL();
+  process.stdout.write(text);
+}
 
 // ── Progress bar ──────────────────────────────────────────────────────────────
-function drawBar(label, percent, barWidth = 38) {
+function drawBar(label, percent, barWidth = 40) {
   const filled = Math.round((percent / 100) * barWidth);
   const empty = barWidth - filled;
   const bar =
@@ -106,75 +151,62 @@ function drawBar(label, percent, barWidth = 38) {
   return `  ${bar} ${pct}  ${dim(label)}`;
 }
 
-// ── Install a package with animated progress bar ──────────────────────────────
+// ── Animate install with real npm running behind ──────────────────────────────
 function animateInstall(pkgName) {
   return new Promise((resolve) => {
     const stages = [
-      { label: "Resolving packages…", end: 12, ms: 90 },
-      { label: "Fetching metadata…", end: 28, ms: 70 },
-      { label: "Downloading tarball…", end: 72, ms: 25 },
-      { label: "Extracting files…", end: 88, ms: 55 },
-      { label: "Linking binaries…", end: 98, ms: 90 },
+      { label: "Resolving packages…", end: 12, ms: 80 },
+      { label: "Fetching metadata…", end: 30, ms: 60 },
+      { label: "Downloading tarball…", end: 75, ms: 22 },
+      { label: "Extracting files…", end: 90, ms: 50 },
+      { label: "Linking binaries…", end: 98, ms: 80 },
     ];
-
     let percent = 0;
     let stageIdx = 0;
     let npmDone = false;
 
-    process.stdout.write(drawBar(stages[0].label, 0) + "\n");
+    process.stdout.write(drawBar(stages[0].label, 0));
 
     const tick = () => {
       const stage = stages[stageIdx];
       if (!stage) return;
-
       const prevEnd = stageIdx > 0 ? stages[stageIdx - 1].end : 0;
-      const step = (stage.end - prevEnd) / 22;
+      const step = (stage.end - prevEnd) / 24;
       percent = Math.min(percent + step, stage.end);
-
-      process.stdout.write("\r\x1b[K");
-      process.stdout.write(drawBar(stage.label, percent));
-
+      process.stdout.write("\r\x1b[K" + drawBar(stage.label, percent));
       if (percent >= stage.end) {
         stageIdx++;
         if (stageIdx >= stages.length) {
           const poll = setInterval(() => {
             if (npmDone) {
               clearInterval(poll);
-              process.stdout.write("\r\x1b[K");
-              process.stdout.write(drawBar("Complete!", 100));
-              process.stdout.write("\n");
+              process.stdout.write(
+                "\r\x1b[K" + drawBar("Complete!", 100) + "\n",
+              );
               resolve();
             }
           }, 80);
           return;
         }
       }
-
       setTimeout(tick, stages[stageIdx]?.ms ?? 50);
     };
 
     setTimeout(tick, stages[0].ms);
-
-    // spawn npm.cmd on Windows, npm on Unix
     const proc = spawn(NPM, ["install", "-g", pkgName], {
       stdio: ["ignore", "pipe", "pipe"],
       shell: isWin,
     });
-
     proc.on("error", () => {
-      // resolve anyway so the UI doesn't hang on spawn failure
       npmDone = true;
     });
-
     proc.on("close", () => {
       npmDone = true;
     });
   });
 }
 
-// ── Check installed status ONCE at startup, cache forever ───────────────────
-// Calling npm on every render was freezing the terminal. We run one
-// 'npm list -g' at startup, parse the output, and never shell out again.
+// ── Installed cache — ONE npm call at startup, Map lookup during render ───────
 function buildInstalledCache() {
   const cache = new Map();
   let out = "";
@@ -182,7 +214,7 @@ function buildInstalledCache() {
     out = execSync(`${NPM} list -g --depth=0`, {
       encoding: "utf8",
       shell: isWin,
-      timeout: 8000,
+      timeout: 10000,
       stdio: ["ignore", "pipe", "ignore"],
     });
   } catch (e) {
@@ -194,169 +226,800 @@ function buildInstalledCache() {
   return cache;
 }
 
+function getLatestVersion(name) {
+  try {
+    return execSync(`${NPM} show ${name} version`, {
+      encoding: "utf8",
+      shell: isWin,
+      timeout: 8000,
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function getInstalledVersion(name) {
+  try {
+    const out = execSync(`${NPM} list -g ${name} --depth=0`, {
+      encoding: "utf8",
+      shell: isWin,
+      timeout: 8000,
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    const match = out.match(new RegExp(name + "@([\\d.]+)"));
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
 let installedCache = new Map();
 const isInstalled = (name) => installedCache.get(name) ?? false;
 
-// ── Render the interactive list ───────────────────────────────────────────────
-const DIV_W = () => Math.min(W() - 2, 70);
+// ── Clipboard ─────────────────────────────────────────────────────────────────
+function copyToClipboard(text) {
+  try {
+    if (isWin) {
+      execSync("clip", { input: text, shell: true });
+    } else if (process.platform === "darwin") {
+      execSync("pbcopy", { input: text });
+    } else {
+      execSync("xclip -selection clipboard || xsel --clipboard --input", {
+        input: text,
+        shell: true,
+      });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ── React hook generator ──────────────────────────────────────────────────────
+function generateUnifiedHook(books) {
+  const cwd = process.cwd();
+  const srcDir = path.join(cwd, "src");
+  const hooksDir = path.join(srcDir, "hooks");
+
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    console.error(
+      red("\n  ✗ No package.json found. Run inside your React project.\n"),
+    );
+    process.exit(1);
+  }
+  const projectPkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  const deps = { ...projectPkg.dependencies, ...projectPkg.devDependencies };
+  if (!deps["react"]) {
+    console.error(red("\n  ✗ React not found in package.json.\n"));
+    process.exit(1);
+  }
+  if (!fs.existsSync(srcDir)) {
+    console.error(red("\n  ✗ No src/ directory found.\n"));
+    process.exit(1);
+  }
+  if (!fs.existsSync(hooksDir)) {
+    fs.mkdirSync(hooksDir, { recursive: true });
+    console.log(green("  ✓ Created src/hooks/"));
+  }
+
+  // Build per-book loader blocks
+  const loaderBlocks = books
+    .map((p) => {
+      const CDN = `https://cdn.jsdelivr.net/npm/${p.name}@latest/chapters`;
+      return `
+// ── ${p.label} ──
+const _${p.cmd}CDN   = '${CDN}';
+let   _${p.cmd}Cache = null;
+let   _${p.cmd}Prom  = null;
+const _${p.cmd}Subs  = new Set();
+
+function _load${p.hook.replace("use", "")}() {
+  if (_${p.cmd}Cache) return Promise.resolve(_${p.cmd}Cache);
+  if (_${p.cmd}Prom)  return _${p.cmd}Prom;
+  _${p.cmd}Prom = fetch(_${p.cmd}CDN + '/meta.json')
+    .then(r => r.json())
+    .then(meta => Promise.all(
+      meta.chapters.map(c => fetch(_${p.cmd}CDN + '/' + c.id + '.json').then(r => r.json()))
+    ).then(results => {
+      const hadiths = results.flat();
+      const _byId   = new Map();
+      hadiths.forEach(h => _byId.set(h.id, h));
+      _${p.cmd}Cache = Object.assign([], hadiths, {
+        metadata:     meta.metadata,
+        chapters:     meta.chapters,
+        get:          (id) => _byId.get(id),
+        getByChapter: (id) => hadiths.filter(h => h.chapterId === id),
+        search:       (q, limit = 0) => {
+          const ql = q.toLowerCase();
+          const r  = hadiths.filter(h =>
+            h.english?.text?.toLowerCase().includes(ql) ||
+            h.english?.narrator?.toLowerCase().includes(ql)
+          );
+          return limit > 0 ? r.slice(0, limit) : r;
+        },
+        getRandom: () => hadiths[Math.floor(Math.random() * hadiths.length)],
+      });
+      _${p.cmd}Subs.forEach(fn => fn(_${p.cmd}Cache));
+      _${p.cmd}Subs.clear();
+      return _${p.cmd}Cache;
+    }));
+  return _${p.cmd}Prom;
+}
+_load${p.hook.replace("use", "")}();
+
+export function ${p.hook}() {
+  const [data, setData] = useState(_${p.cmd}Cache);
+  useEffect(() => {
+    if (_${p.cmd}Cache) { setData(_${p.cmd}Cache); }
+    else { _${p.cmd}Subs.add(setData); return () => _${p.cmd}Subs.delete(setData); }
+  }, []);
+  return data;
+}`;
+    })
+    .join("\n");
+
+  const hookNames = books.map((p) => p.hook).join(", ");
+
+  const hookSrc = `// Auto-generated by: sunnah --react
+// Re-run to regenerate after installing more sunnah packages.
+//
+// Included books: ${books.map((p) => p.label).join(", ")}
+//
+// Usage:
+${books.map((p) => `//   import { ${p.hook} } from '../hooks/useSunnah';`).join("\n")}
+//
+//   const bukhari = useBukhari();
+//   if (!bukhari) return <p>Loading...</p>;
+//   bukhari.get(1)              // hadith by ID
+//   bukhari.search('prayer', 5) // top 5 results
+//   bukhari.getRandom()         // random hadith
+//   bukhari.getByChapter(1)     // all hadiths in chapter
+
+import { useState, useEffect } from 'react';
+${loaderBlocks}
+
+// Unified hook — loads all books in parallel
+export function useSunnah() {
+  const hooks = [${books.map((p) => `${p.hook}()`).join(", ")}];
+  if (hooks.some(h => !h)) return null;
+  return { ${books.map((p) => p.cmd + ": hooks[" + books.indexOf(p) + "]").join(", ")} };
+}
+
+export default useSunnah;
+`;
+
+  const hookFile = path.join(hooksDir, "useSunnah.js");
+  fs.writeFileSync(hookFile, hookSrc, "utf8");
+
+  const div = gray("─".repeat(60));
+  console.log("\n" + div);
+  console.log(bold(cyan("  ✓ Generated: src/hooks/useSunnah.js")));
+  console.log(div);
+  console.log("\n  " + gray("Included books:"));
+  books.forEach((p) =>
+    console.log(
+      "  " + green("▸") + " " + bold(p.label) + gray("  " + p.hook + "()"),
+    ),
+  );
+  console.log("\n  " + gray("Usage:"));
+  console.log(
+    "    " +
+      cyan("import { useSunnah") +
+      (books.length > 1
+        ? ", " +
+          books
+            .slice(0, 2)
+            .map((p) => p.hook)
+            .join(", ")
+        : "") +
+      cyan(" } from '../hooks/useSunnah';"),
+  );
+  console.log("");
+  console.log("    " + gray("// Unified — all books at once"));
+  console.log("    " + gray("const sunnah = useSunnah();"));
+  console.log("    " + gray("if (!sunnah) return <p>Loading...</p>;"));
+  if (books[0])
+    console.log("    " + gray(`sunnah.${books[0].cmd}.getRandom()`));
+  console.log("");
+  console.log("    " + gray("// Per-book hooks still work"));
+  if (books[0]) {
+    console.log("    " + gray(`const ${books[0].cmd} = ${books[0].hook}();`));
+    console.log("    " + gray(`${books[0].cmd}.get(1).english.text`));
+  }
+  console.log("\n" + div + "\n");
+}
+
+// ── Personalized suggestions based on what's installed ───────────────────────
+function getPersonalizedSuggestions() {
+  const installed = PACKAGES.filter((p) => isInstalled(p.name));
+  const missing = PACKAGES.filter((p) => !isInstalled(p.name));
+  const tips = [];
+
+  if (installed.length === 0) {
+    tips.push(
+      cyan("  ▸") +
+        " Run " +
+        bold("sunnah") +
+        " to open the interactive installer",
+    );
+    tips.push(
+      cyan("  ▸") + " Or install directly: " + bold("sunnah install bukhari"),
+    );
+  } else {
+    installed.forEach((p) => {
+      tips.push(
+        cyan("  ▸") +
+          " " +
+          bold(p.cmd + " --random") +
+          gray("  — read a random " + p.label + " hadith"),
+      );
+      tips.push(
+        cyan("  ▸") +
+          " " +
+          bold(p.cmd + ' --search "prayer"') +
+          gray("  — search " + p.label),
+      );
+    });
+    if (installed.length > 1) {
+      tips.push(
+        cyan("  ▸") +
+          " " +
+          bold("sunnah --react") +
+          gray("  — generate useSunnah() hook for all installed books"),
+      );
+    } else if (installed.length === 1) {
+      tips.push(
+        cyan("  ▸") +
+          " " +
+          bold("sunnah --react " + installed[0].cmd) +
+          gray("  — generate React hook for " + installed[0].label),
+      );
+    }
+    if (missing.length > 0) {
+      tips.push(
+        cyan("  ▸") +
+          " " +
+          bold("sunnah") +
+          gray(
+            "  — install more books (" +
+              missing.map((p) => p.label).join(", ") +
+              ")",
+          ),
+      );
+    }
+    tips.push(
+      cyan("  ▸") +
+        " " +
+        bold("sunnah --update") +
+        gray("  — check for updates"),
+    );
+  }
+
+  return tips;
+}
+
+// ── Modes ─────────────────────────────────────────────────────────────────────
+const MODE = { LIST: "list", CONFIRM_UNINSTALL: "confirm_uninstall" };
+
+// ── Interactive render ────────────────────────────────────────────────────────
+function render(state) {
+  const { cursor, selected, mode, confirmTarget, statusMsg } = state;
+  const divW = Math.min(W() - 2, 72);
+  const div = gray("─".repeat(divW));
+  const div2 = gray("═".repeat(divW));
 
-function renderList(selected, cursor) {
-  const div = gray("─".repeat(DIV_W()));
-  const div2 = gray("═".repeat(DIV_W()));
-  const lines = [];
+  clearScreen();
+  let row = 1;
 
-  lines.push("");
-  lines.push(div2);
-  lines.push(
+  writeLine(row++, div2);
+  writeLine(
+    row++,
     bold(cyan("  📚 Sunnah Package Manager")) + gray("  v" + pkg.version),
   );
-  lines.push(
-    gray("  ↑↓ navigate  ") +
-      gray("space select  ") +
-      gray("a all  ") +
-      gray("enter install  ") +
-      gray("q quit"),
+  writeLine(
+    row++,
+    gray("  ↑↓") +
+      " nav  " +
+      gray("space") +
+      " select  " +
+      gray("a") +
+      " all  " +
+      gray("i") +
+      " info  " +
+      gray("u") +
+      " uninstall  " +
+      gray("enter") +
+      " install  " +
+      gray("q") +
+      " quit",
   );
-  lines.push(div2);
-  lines.push("");
+  writeLine(row++, div2);
+  row++;
 
   PACKAGES.forEach((p, i) => {
     const isCursor = i === cursor;
-    const isSelected = selected.has(i);
-    const installed = isInstalled(p.name);
+    const isSel = selected.has(i);
+    const inst = isInstalled(p.name);
 
-    const checkbox = isSelected ? green("[✓]") : gray("[ ]");
+    const checkbox = isSel ? green("[✓]") : gray("[ ]");
     const arrow = isCursor ? cyan("▶") : " ";
     const label = isCursor
       ? bold(white(p.label))
-      : isSelected
+      : isSel
         ? green(p.label)
         : white(p.label);
-    const badge = installed ? dim(gray("  (installed)")) : "";
+    const badge = inst
+      ? dim(green("  ● installed"))
+      : dim(gray("  ○ not installed"));
 
-    lines.push(`  ${arrow} ${checkbox}  ${label}${badge}`);
+    writeLine(row++, `  ${arrow} ${checkbox}  ${label}${badge}`);
 
     if (isCursor) {
-      lines.push(`         ${dim(p.author)}`);
-      lines.push(`         ${gray(p.desc)}`);
-      lines.push(
-        `         ${gray("Hadiths: ")}${yellow(p.hadiths)}   ${gray("CLI: ")}${cyan(p.cmd + " --help")}`,
+      writeLine(row++, `         ${dim(p.author)}`);
+      writeLine(row++, `         ${gray(p.desc)}`);
+      writeLine(
+        row++,
+        `         ${gray("Hadiths: ")}${yellow(p.hadiths)}` +
+          `   ${gray("CLI: ")}${cyan(p.cmd + " --help")}` +
+          (inst ? `   ${gray("try: ")}${cyan(p.cmd + " --random")}` : ""),
       );
-      lines.push("");
+      row++;
     }
   });
 
-  lines.push("");
-  lines.push(div);
+  row++;
+  writeLine(row++, div);
 
-  const count = selected.size;
-  if (count > 0) {
+  if (statusMsg) {
+    writeLine(row++, `  ${yellow("⚠")}  ${yellow(statusMsg)}`);
+  } else if (selected.size > 0) {
     const names = [...selected].map((i) => cyan(PACKAGES[i].name)).join(", ");
-    lines.push(`  ${green("●")} ${bold(String(count))} selected: ${names}`);
+    writeLine(
+      row++,
+      `  ${green("●")} ${bold(String(selected.size))} selected: ${names}`,
+    );
+    writeLine(row++, `  ${dim("enter = install   u = uninstall   i = info")}`);
   } else {
-    lines.push(
-      `  ${gray("Nothing selected — press space to select a package")}`,
+    writeLine(
+      row++,
+      `  ${gray("Nothing selected — press space to select, enter to install focused")}`,
     );
   }
-  lines.push(div);
-  lines.push("");
 
-  return lines;
-}
+  writeLine(row++, div);
 
-function printLines(lines) {
-  process.stdout.write(lines.join("\n") + "\n");
+  if (mode === MODE.CONFIRM_UNINSTALL && confirmTarget !== null) {
+    const p = PACKAGES[confirmTarget];
+    row++;
+    writeLine(
+      row++,
+      `  ${red("⚠  Uninstall ")}${bold(white(p.label))}${red("?")}`,
+    );
+    writeLine(
+      row++,
+      `  ${green("y")} ${gray("confirm")}   ${red("n")} ${gray("cancel")}`,
+    );
+  }
 }
 
-function eraseLines(n) {
-  for (let i = 0; i < n; i++) {
-    clearLine();
-    if (i < n - 1) moveUp(1);
-  }
-  clearLine();
+// ── --list ────────────────────────────────────────────────────────────────────
+function cmdList() {
+  installedCache = buildInstalledCache();
+  const div = gray("─".repeat(60));
+  console.log("\n" + div);
+  console.log(bold(cyan("  Available Sunnah Packages")));
+  console.log(div);
+  PACKAGES.forEach((p) => {
+    const inst = isInstalled(p.name);
+    const badge = inst ? green("  ✓ installed") : red("  ✗ not installed");
+    const version = inst
+      ? dim(gray("  " + (getInstalledVersion(p.name) || "")))
+      : "";
+    console.log(`\n  ${bold(white(p.label))}${badge}${version}`);
+    console.log(`  ${cyan("npm install -g " + p.name)}`);
+    console.log(`  ${dim(p.desc)}`);
+    console.log(
+      `  ${gray("Hadiths: ")}${yellow(p.hadiths)}   ${gray("Author: ")}${magenta(p.author)}`,
+    );
+    if (inst) {
+      console.log(
+        `  ${gray("CLI: ")}${cyan(p.cmd + " --help")}   ${gray("React: ")}${cyan("sunnah --react " + p.cmd)}`,
+      );
+    }
+  });
+  console.log("\n" + div + "\n");
 }
 
-// ── Main ──────────────────────────────────────────────────────────────────────
-async function main() {
-  const rawArgs = process.argv.slice(2);
-  const flags = rawArgs.filter((a) => a.startsWith("-"));
+// ── --update ──────────────────────────────────────────────────────────────────
+function cmdUpdate() {
+  installedCache = buildInstalledCache();
+  const installed = PACKAGES.filter((p) => isInstalled(p.name));
+  if (!installed.length) {
+    console.log(
+      "\n  " +
+        yellow("No sunnah packages installed. Run ") +
+        bold("sunnah") +
+        yellow(" to install.\n"),
+    );
+    return;
+  }
+  const div = gray("─".repeat(60));
+  console.log("\n" + div);
+  console.log(bold(cyan("  Checking for updates…")));
+  console.log(div + "\n");
+
+  let hasUpdates = false;
+  for (const p of installed) {
+    const current = getInstalledVersion(p.name);
+    const latest = getLatestVersion(p.name);
+    if (!current || !latest) {
+      console.log(
+        `  ${yellow("?")} ${bold(p.label)}  ${gray("(could not check)")}`,
+      );
+      continue;
+    }
+    if (current === latest) {
+      console.log(
+        `  ${green("✓")} ${bold(p.label)}  ${gray(current + " — up to date")}`,
+      );
+    } else {
+      hasUpdates = true;
+      console.log(
+        `  ${yellow("↑")} ${bold(p.label)}  ${gray(current)} ${gray("→")} ${green(latest)}`,
+      );
+      console.log(`    ${dim("sunnah install " + p.cmd)}`);
+    }
+  }
 
-  // --version
-  if (flags.some((f) => f === "-v" || f === "--version")) {
-    console.log("");
-    console.log("  " + bold(cyan("sunnah")) + gray(" v" + pkg.version));
+  if (hasUpdates) {
     console.log(
-      "  " + gray("Available packages: ") + yellow(String(PACKAGES.length)),
+      "\n  " +
+        yellow("Updates available. Run ") +
+        bold("sunnah install <name>") +
+        yellow(" to update."),
     );
-    console.log("");
-    process.exit(0);
   }
+  console.log("\n" + div + "\n");
+}
 
-  // --help
-  if (flags.some((f) => f === "-h" || f === "--help")) {
-    const div = gray("─".repeat(60));
-    console.log("");
-    console.log(div);
+// ── sunnah install <cmd> ──────────────────────────────────────────────────────
+async function cmdInstall(targets) {
+  if (!targets.length) {
+    console.error(
+      red(
+        "\n  ✗ Usage: sunnah install <name>  (e.g. sunnah install bukhari)\n",
+      ),
+    );
     console.log(
-      bold(cyan("  Sunnah Package Manager")) + gray("  v" + pkg.version),
+      "  Available: " + PACKAGES.map((p) => cyan(p.cmd)).join(", ") + "\n",
     );
-    console.log(div);
-    console.log("");
-    console.log("  " + bold("Usage:"));
+    process.exit(1);
+  }
+
+  // Resolve names — accept cmd alias or full npm name
+  const toInstall = [];
+  for (const t of targets) {
+    const byCmd = CMD_MAP[t.toLowerCase()];
+    const byName = PACKAGES.find((p) => p.name === t);
+    const found = byCmd || byName;
+    if (!found) {
+      console.log(yellow(`\n  ⚠  Unknown package: "${t}"`));
+      console.log(
+        "  Available: " +
+          PACKAGES.map((p) => cyan(p.cmd) + gray(" (" + p.name + ")")).join(
+            ", ",
+          ),
+      );
+      process.exit(1);
+    }
+    toInstall.push(found);
+  }
+
+  const divW = Math.min(W() - 2, 72);
+  const div2 = gray("═".repeat(divW));
+
+  console.log("\n" + div2);
+  console.log(
+    bold(cyan("  Installing ")) +
+      bold(yellow(String(toInstall.length))) +
+      bold(cyan(" package" + (toInstall.length > 1 ? "s" : "") + "…")),
+  );
+  console.log(div2);
+
+  for (let i = 0; i < toInstall.length; i++) {
+    const p = toInstall[i];
     console.log(
-      "    " +
-        cyan("sunnah") +
-        gray("               Open interactive installer"),
+      "\n  " +
+        cyan("[" + (i + 1) + "/" + toInstall.length + "]") +
+        "  " +
+        bold(white(p.label)),
     );
+    console.log("  " + dim("npm install -g " + p.name) + "\n");
+    await animateInstall(p.name);
+    installedCache.set(p.name, true);
+    console.log("  " + green("✓") + " " + bold(green(p.label)) + " installed");
+    console.log("  " + gray("Usage: ") + cyan(p.cmd + " --help"));
+  }
+
+  console.log("\n" + div2);
+  console.log(
+    "  " +
+      green("✓ Done! ") +
+      toInstall.map((p) => bold(cyan(p.cmd))).join(", ") +
+      gray(" ready."),
+  );
+  console.log(div2 + "\n");
+}
+
+// ── sunnah uninstall <cmd> ────────────────────────────────────────────────────
+function cmdUninstall(targets) {
+  if (!targets.length) {
+    console.error(
+      red(
+        "\n  ✗ Usage: sunnah uninstall <name>  (e.g. sunnah uninstall bukhari)\n",
+      ),
+    );
+    process.exit(1);
+  }
+
+  installedCache = buildInstalledCache();
+  const divW = Math.min(W() - 2, 72);
+  const div2 = gray("═".repeat(divW));
+
+  console.log("\n" + div2);
+
+  for (const t of targets) {
+    const p =
+      CMD_MAP[t.toLowerCase()] || PACKAGES.find((pkg) => pkg.name === t);
+    if (!p) {
+      console.log(yellow(`  ⚠  Unknown: "${t}"`) + "\n");
+      continue;
+    }
+    if (!isInstalled(p.name)) {
+      console.log(gray(`  ○  ${p.label} is not installed, skipping.`));
+      continue;
+    }
+    console.log(yellow("  Uninstalling ") + bold(white(p.label)) + yellow("…"));
+    try {
+      execSync(`${NPM} uninstall -g ${p.name}`, {
+        stdio: "inherit",
+        shell: isWin,
+      });
+      installedCache.set(p.name, false);
+      console.log(
+        green("  ✓ ") + bold(green(p.label)) + green(" uninstalled.\n"),
+      );
+    } catch {
+      console.log(red("  ✗ Failed to uninstall " + p.label + "\n"));
+    }
+  }
+
+  console.log(div2 + "\n");
+}
+
+// ── --version (personalized) ──────────────────────────────────────────────────
+function cmdVersion() {
+  installedCache = buildInstalledCache();
+  const installed = PACKAGES.filter((p) => isInstalled(p.name));
+  const div = gray("─".repeat(60));
+
+  console.log("\n" + div);
+  console.log(bold(cyan("  📿 sunnah")) + gray("  v" + pkg.version));
+  console.log(div);
+  console.log(
+    "  " + gray("Available packages : ") + yellow(String(PACKAGES.length)),
+  );
+  console.log(
+    "  " +
+      gray("Installed          : ") +
+      green(String(installed.length)) +
+      gray(" / " + PACKAGES.length),
+  );
+
+  if (installed.length > 0) {
     console.log(
-      "    " +
-        cyan("sunnah") +
-        green(" --list") +
-        gray("       List all available packages"),
+      "  " +
+        gray("Your collection    : ") +
+        installed.map((p) => cyan(p.label)).join(gray(", ")),
+    );
+    const totalHadiths = installed.reduce(
+      (acc, p) => acc + parseInt(p.hadiths.replace(/,/g, "")),
+      0,
     );
     console.log(
-      "    " + cyan("sunnah") + green(" -v") + gray("           Show version"),
+      "  " +
+        gray("Total hadiths      : ") +
+        bold(yellow(totalHadiths.toLocaleString())),
     );
+  }
+
+  console.log("\n" + div + "\n");
+}
+
+// ── --help (personalized) ─────────────────────────────────────────────────────
+function cmdHelp() {
+  installedCache = buildInstalledCache();
+  const div = gray("─".repeat(60));
+
+  console.log("\n" + div);
+  console.log(
+    bold(cyan("  📿 Sunnah Package Manager")) + gray("  v" + pkg.version),
+  );
+  console.log(div);
+
+  console.log("\n  " + bold("Commands:"));
+  console.log(
+    "    " +
+      cyan("sunnah") +
+      gray("                     Open interactive installer UI"),
+  );
+  console.log(
+    "    " +
+      cyan("sunnah install") +
+      yellow(" <name>") +
+      gray("     Install a package directly"),
+  );
+  console.log(
+    "    " +
+      cyan("sunnah uninstall") +
+      yellow(" <name>") +
+      gray("   Uninstall a package"),
+  );
+  console.log(
+    "    " +
+      cyan("sunnah --react") +
+      gray("              Generate unified useSunnah() React hook"),
+  );
+  console.log(
+    "    " +
+      cyan("sunnah --react") +
+      yellow(" <books>") +
+      gray("   Generate hook for specific books"),
+  );
+  console.log(
+    "    " +
+      cyan("sunnah --list") +
+      gray("               List all packages with install status"),
+  );
+  console.log(
+    "    " +
+      cyan("sunnah --update") +
+      gray("             Check installed packages for updates"),
+  );
+  console.log(
+    "    " +
+      cyan("sunnah -v") +
+      gray("                   Version + your collection stats"),
+  );
+  console.log(
+    "    " +
+      cyan("sunnah -h") +
+      gray("                   This help + personalized tips"),
+  );
+
+  console.log("\n  " + bold("Package names (use any form):"));
+  PACKAGES.forEach((p) => {
     console.log(
       "    " +
-        cyan("sunnah") +
-        green(" -h") +
-        gray("           Show this help"),
+        cyan(p.cmd.padEnd(12)) +
+        gray(p.name.padEnd(24)) +
+        yellow(p.hadiths + " hadiths"),
     );
-    console.log("");
-    console.log("  " + bold("Controls (interactive mode):"));
-    console.log("    " + green("↑ ↓") + gray("     Navigate packages"));
-    console.log("    " + green("space") + gray("   Toggle selection"));
-    console.log("    " + green("a") + gray("       Toggle all / deselect all"));
-    console.log("    " + green("enter") + gray("   Install selected packages"));
-    console.log("    " + green("q") + gray("       Quit"));
-    console.log("");
-    console.log(div);
-    console.log("");
+  });
+
+  console.log("\n  " + bold("Examples:"));
+  console.log("    " + dim("sunnah install bukhari"));
+  console.log("    " + dim("sunnah install bukhari muslim tirmidhi"));
+  console.log("    " + dim("sunnah uninstall dawud"));
+  console.log("    " + dim("sunnah --react"));
+  console.log("    " + dim("sunnah --react bukhari muslim"));
+  console.log("    " + dim("sunnah --update"));
+
+  console.log("\n  " + bold("Interactive UI controls:"));
+  console.log("    " + green("↑ ↓") + gray("      Navigate packages"));
+  console.log("    " + green("space") + gray("    Toggle select"));
+  console.log("    " + green("a") + gray("        Select all / deselect all"));
+  console.log(
+    "    " + green("i") + gray("        Show info + installed version"),
+  );
+  console.log("    " + green("u") + gray("        Uninstall selected"));
+  console.log(
+    "    " +
+      green("enter") +
+      gray("    Install selected (or focused if none selected)"),
+  );
+  console.log("    " + green("q") + gray("        Quit"));
+
+  // Personalized tips
+  const tips = getPersonalizedSuggestions();
+  if (tips.length) {
+    console.log("\n" + div);
+    console.log(bold("  💡 Suggested for you:"));
+    tips.forEach((t) => console.log(t));
+  }
+
+  console.log("\n" + div + "\n");
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+async function main() {
+  const rawArgs = process.argv.slice(2);
+  const flags = rawArgs.filter((a) => a.startsWith("-"));
+  const positional = rawArgs.filter((a) => !a.startsWith("-"));
+
+  // sunnah -v / --version
+  if (flags.some((f) => f === "-v" || f === "--version")) {
+    cmdVersion();
+    process.exit(0);
+  }
+
+  // sunnah -h / --help
+  if (flags.some((f) => f === "-h" || f === "--help")) {
+    cmdHelp();
     process.exit(0);
   }
 
-  // --list
+  // sunnah --list / -l
   if (flags.some((f) => f === "--list" || f === "-l")) {
+    cmdList();
+    process.exit(0);
+  }
+
+  // sunnah --update
+  if (flags.some((f) => f === "--update")) {
+    cmdUpdate();
+    process.exit(0);
+  }
+
+  // sunnah install <names...>
+  if (positional[0] === "install") {
+    await cmdInstall(positional.slice(1));
+    process.exit(0);
+  }
+
+  // sunnah uninstall <names...>
+  if (positional[0] === "uninstall") {
+    cmdUninstall(positional.slice(1));
+    process.exit(0);
+  }
+
+  // sunnah --react [book1 book2 ...]
+  if (flags.some((f) => f === "--react")) {
     installedCache = buildInstalledCache();
-    const div = gray("─".repeat(60));
-    console.log("");
-    console.log(div);
-    console.log(bold(cyan("  Available Sunnah Packages")));
-    console.log(div);
-    PACKAGES.forEach((p) => {
-      const inst = isInstalled(p.name) ? green("  ✓ installed") : "";
-      console.log("");
-      console.log(`  ${bold(white(p.label))}${inst}`);
-      console.log(`  ${cyan("npm install -g " + p.name)}`);
-      console.log(`  ${dim(p.desc)}`);
-      console.log(
-        `  ${gray("Hadiths: ")}${yellow(p.hadiths)}   ${gray("Author: ")}${magenta(p.author)}`,
+    // If specific books given after --react, use those; else use all installed
+    const requestedCmds = positional; // e.g. ["bukhari", "muslim"]
+    let books;
+    if (requestedCmds.length > 0) {
+      books = requestedCmds
+        .map((cmd) => CMD_MAP[cmd.toLowerCase()])
+        .filter(Boolean);
+      const unknown = requestedCmds.filter(
+        (cmd) => !CMD_MAP[cmd.toLowerCase()],
       );
-    });
-    console.log("");
-    console.log(div);
-    console.log("");
+      if (unknown.length) {
+        console.log(yellow("\n  ⚠  Unknown books: " + unknown.join(", ")));
+        console.log("  Available: " + Object.keys(CMD_MAP).join(", ") + "\n");
+      }
+    } else {
+      books = PACKAGES.filter((p) => isInstalled(p.name));
+      if (!books.length) {
+        console.log(yellow("\n  ⚠  No sunnah packages installed yet."));
+        console.log(
+          "  Run " +
+            bold("sunnah") +
+            " to install some first, or specify books explicitly:",
+        );
+        console.log("  " + dim("sunnah --react bukhari muslim") + "\n");
+        process.exit(1);
+      }
+    }
+    if (!books.length) {
+      console.log(red("\n  ✗ No valid books specified.\n"));
+      process.exit(1);
+    }
+    generateUnifiedHook(books);
     process.exit(0);
   }
 
@@ -366,32 +1029,47 @@ async function main() {
     process.exit(1);
   }
 
-  // Build installed cache once — never call npm during rendering
-  process.stdout.write(
-    "\n  " + "\x1b[90m" + "Checking installed packages…" + "\x1b[0m",
-  );
+  // Build cache
+  process.stdout.write("\n  " + gray("Checking installed packages…"));
   installedCache = buildInstalledCache();
   process.stdout.write("\r\x1b[K");
 
-  readline.emitKeypressEvents(process.stdin);
-  process.stdin.setRawMode(true);
-  hideCursor();
+  // Load persisted selection
+  const persisted = loadPersistedState();
+  const lastSelected = new Set(
+    (persisted.lastSelected || []).filter((i) => i < PACKAGES.length),
+  );
 
-  let cursor = 0;
-  let selected = new Set();
-  let prevCount = 0;
+  enterAltScreen();
+  hideCursor();
 
-  const draw = () => {
-    const lines = renderList(selected, cursor);
-    if (prevCount > 0) eraseLines(prevCount);
-    printLines(lines);
-    prevCount = lines.length;
+  const state = {
+    cursor: 0,
+    selected: lastSelected, // pre-check last session's selections
+    mode: MODE.LIST,
+    confirmTarget: null,
+    statusMsg: "",
   };
 
-  draw();
+  let statusTimer = null;
+
+  function setStatus(msg, ms = 2500) {
+    state.statusMsg = msg;
+    render(state);
+    if (statusTimer) clearTimeout(statusTimer);
+    statusTimer = setTimeout(() => {
+      state.statusMsg = "";
+      render(state);
+    }, ms);
+  }
+
+  render(state);
 
   const cleanup = () => {
+    // Persist current selection before exiting
+    savePersistedState({ lastSelected: [...state.selected] });
     showCursor();
+    leaveAltScreen();
     try {
       process.stdin.setRawMode(false);
     } catch {}
@@ -400,112 +1078,208 @@ async function main() {
 
   process.on("SIGINT", () => {
     cleanup();
-    console.log("");
     process.exit(0);
   });
 
+  readline.emitKeypressEvents(process.stdin);
+  process.stdin.setRawMode(true);
+
   process.stdin.on("keypress", async (str, key) => {
     if (!key) return;
 
-    // Quit
+    // ── Confirm uninstall mode ────────────────────────────────────────────────
+    if (state.mode === MODE.CONFIRM_UNINSTALL) {
+      if (str === "y" || str === "Y") {
+        const p = PACKAGES[state.confirmTarget];
+        state.mode = MODE.LIST;
+        state.confirmTarget = null;
+        cleanup();
+        console.log(
+          "\n  " +
+            yellow("Uninstalling ") +
+            bold(white(p.label)) +
+            yellow("…\n"),
+        );
+        try {
+          execSync(`${NPM} uninstall -g ${p.name}`, {
+            stdio: "inherit",
+            shell: isWin,
+          });
+          installedCache.set(p.name, false);
+          state.selected.delete(PACKAGES.indexOf(p));
+          console.log(
+            "\n  " +
+              green("✓ ") +
+              bold(green(p.label)) +
+              green(" uninstalled.\n"),
+          );
+        } catch {
+          console.log("\n  " + red("✗ Failed to uninstall " + p.label) + "\n");
+        }
+        await sleep(1200);
+        enterAltScreen();
+        hideCursor();
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        render(state);
+      } else {
+        state.mode = MODE.LIST;
+        state.confirmTarget = null;
+        render(state);
+      }
+      return;
+    }
+
+    // ── Normal mode ───────────────────────────────────────────────────────────
+
     if (key.name === "q" || (key.ctrl && key.name === "c")) {
       cleanup();
-      if (prevCount > 0) eraseLines(prevCount);
       console.log("\n  " + gray("Goodbye.\n"));
       process.exit(0);
     }
 
-    // Navigate
     if (key.name === "up") {
-      cursor = (cursor - 1 + PACKAGES.length) % PACKAGES.length;
-      draw();
+      state.cursor = (state.cursor - 1 + PACKAGES.length) % PACKAGES.length;
+      render(state);
       return;
     }
     if (key.name === "down") {
-      cursor = (cursor + 1) % PACKAGES.length;
-      draw();
+      state.cursor = (state.cursor + 1) % PACKAGES.length;
+      render(state);
       return;
     }
 
-    // Toggle selection
     if (str === " ") {
-      if (selected.has(cursor)) selected.delete(cursor);
-      else selected.add(cursor);
-      draw();
+      if (state.selected.has(state.cursor)) state.selected.delete(state.cursor);
+      else state.selected.add(state.cursor);
+      render(state);
       return;
     }
 
-    // Toggle all
     if (str === "a" || str === "A") {
-      if (selected.size === PACKAGES.length) selected.clear();
-      else PACKAGES.forEach((_, i) => selected.add(i));
-      draw();
+      if (state.selected.size === PACKAGES.length) state.selected.clear();
+      else PACKAGES.forEach((_, i) => state.selected.add(i));
+      render(state);
       return;
     }
 
-    // Install
+    // i = info
+    if (str === "i" || str === "I") {
+      const p = PACKAGES[state.cursor];
+      const inst = isInstalled(p.name);
+      const ver = inst ? getInstalledVersion(p.name) : null;
+      setStatus(
+        `${p.label}  |  ${p.hadiths} hadiths  |  ${p.author}  |  ${inst ? "v" + ver + " installed  CLI: " + p.cmd + " --help" : "not installed"}`,
+        4000,
+      );
+      return;
+    }
+
+    // u = uninstall
+    if (str === "u" || str === "U") {
+      const targets =
+        state.selected.size > 0 ? [...state.selected] : [state.cursor];
+      const toRemove = targets.filter((i) => isInstalled(PACKAGES[i].name));
+      if (!toRemove.length) {
+        setStatus("No installed packages selected.");
+        return;
+      }
+      state.mode = MODE.CONFIRM_UNINSTALL;
+      state.confirmTarget = toRemove[0];
+      render(state);
+      return;
+    }
+
+    // enter = install
     if (key.name === "return") {
-      if (selected.size === 0) return;
+      const targets =
+        state.selected.size > 0
+          ? [...state.selected].map((i) => PACKAGES[i])
+          : [PACKAGES[state.cursor]];
+      const toInstall = targets.filter((p) => !isInstalled(p.name));
+
+      if (!toInstall.length) {
+        setStatus("All selected packages are already installed.");
+        return;
+      }
 
       cleanup();
-      if (prevCount > 0) eraseLines(prevCount);
+      const divW = Math.min(W() - 2, 72);
+      const div = gray("─".repeat(divW));
+      const div2 = gray("═".repeat(divW));
 
-      const toInstall = [...selected].map((i) => PACKAGES[i]);
-      const total = toInstall.length;
-      const div = gray("─".repeat(DIV_W()));
-      const div2 = gray("═".repeat(DIV_W()));
-
-      console.log("");
-      console.log(div2);
+      console.log("\n" + div2);
       console.log(
         bold(cyan("  Installing ")) +
-          bold(yellow(String(total))) +
-          bold(cyan(" package" + (total > 1 ? "s" : "") + "…")),
+          bold(yellow(String(toInstall.length))) +
+          bold(cyan(" package" + (toInstall.length > 1 ? "s" : "") + "…")),
       );
       console.log(div2);
 
       for (let i = 0; i < toInstall.length; i++) {
         const p = toInstall[i];
-        console.log("");
         console.log(
-          `  ${cyan("[" + (i + 1) + "/" + total + "]")}  ${bold(white(p.label))}`,
+          "\n  " +
+            cyan("[" + (i + 1) + "/" + toInstall.length + "]") +
+            "  " +
+            bold(white(p.label)),
         );
-        console.log(`  ${dim("npm install -g " + p.name)}`);
-        console.log("");
-
+        console.log("  " + dim("npm install -g " + p.name) + "\n");
         await animateInstall(p.name);
-        installedCache.set(p.name, true); // update cache
-
+        installedCache.set(p.name, true);
         console.log(
-          `  ${green("✓")} ${bold(green(p.label))} installed successfully`,
+          "  " + green("✓") + " " + bold(green(p.label)) + " installed",
         );
-        console.log(`  ${gray("Usage: ")}${cyan(p.cmd + " --help")}`);
+        console.log("  " + gray("Usage: ") + cyan(p.cmd + " --help"));
       }
 
-      console.log("");
-      console.log(div2);
+      console.log("\n" + div2);
       console.log(
-        `  ${green("✓")} All done! ` +
-          bold(yellow(String(total))) +
-          ` package${total > 1 ? "s" : ""} installed globally.`,
+        "  " +
+          green("✓ All done! ") +
+          bold(yellow(String(toInstall.length))) +
+          " package" +
+          (toInstall.length > 1 ? "s" : "") +
+          " installed globally.",
       );
       console.log("");
-      toInstall.forEach((p) => {
+      toInstall.forEach((p) =>
+        console.log(
+          "  " +
+            cyan("▸") +
+            " " +
+            bold(p.cmd) +
+            gray(" --help") +
+            "  " +
+            dim(p.label),
+        ),
+      );
+
+      // Personalized next steps
+      const installed = PACKAGES.filter((p) => isInstalled(p.name));
+      if (installed.length > 1) {
         console.log(
-          `  ${cyan("▸")} ${bold(p.cmd)} ${gray("--help")}  ${dim("·")}  ${dim(p.label)}`,
+          "\n  " +
+            dim("Tip: run ") +
+            bold("sunnah --react") +
+            dim(" to generate a unified React hook for all your books"),
         );
-      });
-      console.log(div2);
-      console.log("");
+      }
 
+      console.log(div2 + "\n");
       showCursor();
       process.exit(0);
     }
   });
 }
 
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
 main().catch((err) => {
   showCursor();
+  leaveAltScreen();
   console.error(red("\n  ✗ " + err.message + "\n"));
   process.exit(1);
 });