sunnah 1.2.0 → 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",
@@ -52,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",
@@ -60,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",
@@ -68,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",
@@ -76,10 +102,14 @@ 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: use alternate screen buffer to avoid scroll issues ──────────────
+// 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;
 
@@ -92,8 +122,8 @@ function leaveAltScreen() {
 function clearScreen() {
   process.stdout.write("\x1b[2J\x1b[H");
 }
-function moveTo(row, col) {
-  process.stdout.write(`\x1b[${row};${col}H`);
+function moveTo(r, col) {
+  process.stdout.write(`\x1b[${r};${col}H`);
 }
 function hideCursor() {
   process.stdout.write("\x1b[?25l");
@@ -121,7 +151,7 @@ function drawBar(label, percent, barWidth = 40) {
   return `  ${bar} ${pct}  ${dim(label)}`;
 }
 
-// ── Install a package with animated single progress bar ───────────────────────
+// ── Animate install with real npm running behind ──────────────────────────────
 function animateInstall(pkgName) {
   return new Promise((resolve) => {
     const stages = [
@@ -131,29 +161,22 @@ function animateInstall(pkgName) {
       { label: "Extracting files…", end: 90, ms: 50 },
       { label: "Linking binaries…", end: 98, ms: 80 },
     ];
-
     let percent = 0;
     let stageIdx = 0;
     let npmDone = false;
 
-    // Write bar ONCE — all updates overwrite this same line with \r
     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) / 24;
       percent = Math.min(percent + step, stage.end);
-
-      // Overwrite the SAME line — no \n, just \r
       process.stdout.write("\r\x1b[K" + drawBar(stage.label, percent));
-
       if (percent >= stage.end) {
         stageIdx++;
         if (stageIdx >= stages.length) {
-          // Spin until npm actually finishes
           const poll = setInterval(() => {
             if (npmDone) {
               clearInterval(poll);
@@ -166,13 +189,10 @@ function animateInstall(pkgName) {
           return;
         }
       }
-
       setTimeout(tick, stages[stageIdx]?.ms ?? 50);
     };
 
     setTimeout(tick, stages[0].ms);
-
-    // Actually run npm install -g
     const proc = spawn(NPM, ["install", "-g", pkgName], {
       stdio: ["ignore", "pipe", "pipe"],
       shell: isWin,
@@ -186,7 +206,7 @@ function animateInstall(pkgName) {
   });
 }
 
-// ── Installed cache — built ONCE, never during render ────────────────────────
+// ── Installed cache — ONE npm call at startup, Map lookup during render ───────
 function buildInstalledCache() {
   const cache = new Map();
   let out = "";
@@ -206,7 +226,6 @@ function buildInstalledCache() {
   return cache;
 }
 
-// Get latest version from npm registry (fast, single HTTP call)
 function getLatestVersion(name) {
   try {
     return execSync(`${NPM} show ${name} version`, {
@@ -220,7 +239,6 @@ function getLatestVersion(name) {
   }
 }
 
-// Get currently installed version
 function getInstalledVersion(name) {
   try {
     const out = execSync(`${NPM} list -g ${name} --depth=0`, {
@@ -239,10 +257,253 @@ function getInstalledVersion(name) {
 let installedCache = new Map();
 const isInstalled = (name) => installedCache.get(name) ?? false;
 
+// ── 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" };
 
-// ── Render: full-screen, uses alt buffer so no scroll ever ───────────────────
+// ── Interactive render ────────────────────────────────────────────────────────
 function render(state) {
   const { cursor, selected, mode, confirmTarget, statusMsg } = state;
   const divW = Math.min(W() - 2, 72);
@@ -250,10 +511,8 @@ function render(state) {
   const div2 = gray("═".repeat(divW));
 
   clearScreen();
-
   let row = 1;
 
-  // Header
   writeLine(row++, div2);
   writeLine(
     row++,
@@ -262,7 +521,7 @@ function render(state) {
   writeLine(
     row++,
     gray("  ↑↓") +
-      " navigate  " +
+      " nav  " +
       gray("space") +
       " select  " +
       gray("a") +
@@ -277,9 +536,8 @@ function render(state) {
       " quit",
   );
   writeLine(row++, div2);
-  row++; // blank
+  row++;
 
-  // Package list
   PACKAGES.forEach((p, i) => {
     const isCursor = i === cursor;
     const isSel = selected.has(i);
@@ -305,16 +563,15 @@ function render(state) {
         row++,
         `         ${gray("Hadiths: ")}${yellow(p.hadiths)}` +
           `   ${gray("CLI: ")}${cyan(p.cmd + " --help")}` +
-          (inst ? `   ${gray("run: ")}${cyan(p.cmd + " 1")}` : ""),
+          (inst ? `   ${gray("try: ")}${cyan(p.cmd + " --random")}` : ""),
       );
-      row++; // blank after expanded
+      row++;
     }
   });
 
-  row++; // blank
+  row++;
   writeLine(row++, div);
 
-  // Status / selection footer
   if (statusMsg) {
     writeLine(row++, `  ${yellow("⚠")}  ${yellow(statusMsg)}`);
   } else if (selected.size > 0) {
@@ -323,20 +580,16 @@ function render(state) {
       row++,
       `  ${green("●")} ${bold(String(selected.size))} selected: ${names}`,
     );
-    writeLine(
-      row++,
-      `  ${dim("Press enter to install, u to uninstall selected")}`,
-    );
+    writeLine(row++, `  ${dim("enter = install   u = uninstall   i = info")}`);
   } else {
     writeLine(
       row++,
-      `  ${gray("Nothing selected — press space to select a package")}`,
+      `  ${gray("Nothing selected — press space to select, enter to install focused")}`,
     );
   }
 
   writeLine(row++, div);
 
-  // Confirm uninstall overlay
   if (mode === MODE.CONFIRM_UNINSTALL && confirmTarget !== null) {
     const p = PACKAGES[confirmTarget];
     row++;
@@ -351,37 +604,45 @@ function render(state) {
   }
 }
 
-// ── Non-interactive: --list ───────────────────────────────────────────────────
+// ── --list ────────────────────────────────────────────────────────────────────
 function cmdList() {
   installedCache = buildInstalledCache();
   const div = gray("─".repeat(60));
-  console.log("");
-  console.log(div);
+  console.log("\n" + div);
   console.log(bold(cyan("  Available Sunnah Packages")));
   console.log(div);
   PACKAGES.forEach((p) => {
-    const inst = isInstalled(p.name)
-      ? green("  ✓ installed")
-      : red("  ✗ not installed");
-    console.log("");
-    console.log(`  ${bold(white(p.label))}${inst}`);
+    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("");
-  console.log(div);
-  console.log("");
+  console.log("\n" + div + "\n");
 }
 
-// ── Non-interactive: --update ─────────────────────────────────────────────────
+// ── --update ──────────────────────────────────────────────────────────────────
 function cmdUpdate() {
   installedCache = buildInstalledCache();
   const installed = PACKAGES.filter((p) => isInstalled(p.name));
   if (!installed.length) {
-    console.log("\n  " + yellow("No sunnah packages installed.\n"));
+    console.log(
+      "\n  " +
+        yellow("No sunnah packages installed. Run ") +
+        bold("sunnah") +
+        yellow(" to install.\n"),
+    );
     return;
   }
   const div = gray("─".repeat(60));
@@ -389,11 +650,14 @@ function cmdUpdate() {
   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("?")} ${p.label}  ${gray("(could not check)")}`);
+      console.log(
+        `  ${yellow("?")} ${bold(p.label)}  ${gray("(could not check)")}`,
+      );
       continue;
     }
     if (current === latest) {
@@ -401,105 +665,387 @@ function cmdUpdate() {
         `  ${green("✓")} ${bold(p.label)}  ${gray(current + " — up to date")}`,
       );
     } else {
+      hasUpdates = true;
       console.log(
-        `  ${yellow("↑")} ${bold(p.label)}  ${gray(current)} → ${green(latest)}  ${dim("(run: npm install -g " + p.name + ")")}`,
+        `  ${yellow("↑")} ${bold(p.label)}  ${gray(current)} ${gray("→")} ${green(latest)}`,
       );
+      console.log(`    ${dim("sunnah install " + p.cmd)}`);
     }
   }
+
+  if (hasUpdates) {
+    console.log(
+      "\n  " +
+        yellow("Updates available. Run ") +
+        bold("sunnah install <name>") +
+        yellow(" to update."),
+    );
+  }
   console.log("\n" + div + "\n");
 }
 
-// ── Main ──────────────────────────────────────────────────────────────────────
-async function main() {
-  const rawArgs = process.argv.slice(2);
-  const flags = rawArgs.filter((a) => a.startsWith("-"));
-
-  // --version
-  if (flags.some((f) => f === "-v" || f === "--version")) {
-    console.log("\n  " + bold(cyan("sunnah")) + gray(" v" + pkg.version));
+// ── 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(
-      "  " + gray("Packages: ") + yellow(String(PACKAGES.length)) + "\n",
+      "  Available: " + PACKAGES.map((p) => cyan(p.cmd)).join(", ") + "\n",
     );
-    process.exit(0);
+    process.exit(1);
   }
 
-  // --help
-  if (flags.some((f) => f === "-h" || f === "--help")) {
-    const div = gray("─".repeat(60));
-    console.log("\n" + div);
+  // 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(
-      bold(cyan("  Sunnah Package Manager")) + gray("  v" + pkg.version),
+      "\n  " +
+        cyan("[" + (i + 1) + "/" + toInstall.length + "]") +
+        "  " +
+        bold(white(p.label)),
     );
-    console.log(div + "\n");
-    console.log("  " + bold("Usage:"));
-    console.log(
-      "    " + cyan("sunnah") + gray("                Open interactive UI"),
+    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 packages + install status"),
+      "  " +
+        gray("Your collection    : ") +
+        installed.map((p) => cyan(p.label)).join(gray(", ")),
     );
-    console.log(
-      "    " +
-        cyan("sunnah") +
-        green(" --update") +
-        gray("      Check all installed packages for updates"),
+    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"),
-    );
-    console.log("\n  " + bold("Interactive controls:"));
-    console.log("    " + green("↑ ↓") + gray("      Navigate"));
-    console.log("    " + green("space") + gray("    Toggle select"));
-    console.log(
-      "    " + green("a") + gray("        Select all / deselect all"),
+        cyan(p.cmd.padEnd(12)) +
+        gray(p.name.padEnd(24)) +
+        yellow(p.hadiths + " hadiths"),
     );
-    console.log("    " + green("i") + gray("        Show package info"));
-    console.log("    " + green("u") + gray("        Uninstall selected"));
-    console.log("    " + green("enter") + gray("    Install selected"));
-    console.log("    " + green("q") + gray("        Quit"));
-    console.log("\n" + div + "\n");
+  });
+
+  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);
   }
 
-  // --list
+  // sunnah -h / --help
+  if (flags.some((f) => f === "-h" || f === "--help")) {
+    cmdHelp();
+    process.exit(0);
+  }
+
+  // sunnah --list / -l
   if (flags.some((f) => f === "--list" || f === "-l")) {
     cmdList();
     process.exit(0);
   }
 
-  // --update
+  // 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();
+    // 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()],
+      );
+      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);
+  }
+
   // ── Interactive mode ────────────────────────────────────────────────────────
   if (!process.stdin.isTTY) {
     console.error(red("\n  ✗ Interactive mode requires a TTY terminal.\n"));
     process.exit(1);
   }
 
-  // Build cache before entering alt screen
+  // Build cache
   process.stdout.write("\n  " + gray("Checking installed packages…"));
   installedCache = buildInstalledCache();
   process.stdout.write("\r\x1b[K");
 
-  // Enter alternate screen buffer — this completely prevents scroll issues
+  // Load persisted selection
+  const persisted = loadPersistedState();
+  const lastSelected = new Set(
+    (persisted.lastSelected || []).filter((i) => i < PACKAGES.length),
+  );
+
   enterAltScreen();
   hideCursor();
 
   const state = {
     cursor: 0,
-    selected: new Set(),
+    selected: lastSelected, // pre-check last session's selections
     mode: MODE.LIST,
     confirmTarget: null,
     statusMsg: "",
@@ -507,7 +1053,7 @@ async function main() {
 
   let statusTimer = null;
 
-  function setStatus(msg, ms = 2000) {
+  function setStatus(msg, ms = 2500) {
     state.statusMsg = msg;
     render(state);
     if (statusTimer) clearTimeout(statusTimer);
@@ -520,6 +1066,8 @@ async function main() {
   render(state);
 
   const cleanup = () => {
+    // Persist current selection before exiting
+    savePersistedState({ lastSelected: [...state.selected] });
     showCursor();
     leaveAltScreen();
     try {
@@ -539,13 +1087,12 @@ async function main() {
   process.stdin.on("keypress", async (str, key) => {
     if (!key) return;
 
-    // ── Confirm uninstall mode ──────────────────────────────────────────────
+    // ── 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  " +
@@ -553,7 +1100,6 @@ async function main() {
             bold(white(p.label)) +
             yellow("…\n"),
         );
-
         try {
           execSync(`${NPM} uninstall -g ${p.name}`, {
             stdio: "inherit",
@@ -568,12 +1114,9 @@ async function main() {
               green(" uninstalled.\n"),
           );
         } catch {
-          console.log("\n  " + red("✗ Failed to uninstall " + p.label + "\n"));
+          console.log("\n  " + red("✗ Failed to uninstall " + p.label) + "\n");
         }
-
         await sleep(1200);
-
-        // Re-enter interactive UI
         enterAltScreen();
         hideCursor();
         readline.emitKeypressEvents(process.stdin);
@@ -587,16 +1130,14 @@ async function main() {
       return;
     }
 
-    // ── Normal list mode ────────────────────────────────────────────────────
+    // ── Normal mode ───────────────────────────────────────────────────────────
 
-    // Quit
     if (key.name === "q" || (key.ctrl && key.name === "c")) {
       cleanup();
       console.log("\n  " + gray("Goodbye.\n"));
       process.exit(0);
     }
 
-    // Navigate
     if (key.name === "up") {
       state.cursor = (state.cursor - 1 + PACKAGES.length) % PACKAGES.length;
       render(state);
@@ -608,7 +1149,6 @@ async function main() {
       return;
     }
 
-    // Toggle select
     if (str === " ") {
       if (state.selected.has(state.cursor)) state.selected.delete(state.cursor);
       else state.selected.add(state.cursor);
@@ -616,7 +1156,6 @@ async function main() {
       return;
     }
 
-    // Select all / deselect all
     if (str === "a" || str === "A") {
       if (state.selected.size === PACKAGES.length) state.selected.clear();
       else PACKAGES.forEach((_, i) => state.selected.add(i));
@@ -624,42 +1163,39 @@ async function main() {
       return;
     }
 
-    // Info
+    // i = info
     if (str === "i" || str === "I") {
       const p = PACKAGES[state.cursor];
       const inst = isInstalled(p.name);
-      const version = inst ? getInstalledVersion(p.name) : null;
-      const msg = `${p.label} | ${p.hadiths} hadiths | ${inst ? "v" + version + " installed" : "not installed"}`;
-      setStatus(msg, 3000);
+      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;
     }
 
-    // Uninstall
+    // u = uninstall
     if (str === "u" || str === "U") {
       const targets =
         state.selected.size > 0 ? [...state.selected] : [state.cursor];
-
-      // Only uninstall packages that are actually installed
       const toRemove = targets.filter((i) => isInstalled(PACKAGES[i].name));
       if (!toRemove.length) {
-        setStatus("No installed packages selected to uninstall.");
+        setStatus("No installed packages selected.");
         return;
       }
-
-      // Confirm one by one
       state.mode = MODE.CONFIRM_UNINSTALL;
       state.confirmTarget = toRemove[0];
       render(state);
       return;
     }
 
-    // Install
+    // enter = install
     if (key.name === "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) {
@@ -668,8 +1204,6 @@ async function main() {
       }
 
       cleanup();
-
-      const total = toInstall.length;
       const divW = Math.min(W() - 2, 72);
       const div = gray("─".repeat(divW));
       const div2 = gray("═".repeat(divW));
@@ -677,8 +1211,8 @@ async function main() {
       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);
 
@@ -686,15 +1220,13 @@ async function main() {
         const p = toInstall[i];
         console.log(
           "\n  " +
-            cyan("[" + (i + 1) + "/" + total + "]") +
+            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",
         );
@@ -705,10 +1237,10 @@ async function main() {
       console.log(
         "  " +
           green("✓ All done! ") +
-          bold(yellow(String(total))) +
+          bold(yellow(String(toInstall.length))) +
           " package" +
-          (total > 1 ? "s" : "") +
-          " installed.",
+          (toInstall.length > 1 ? "s" : "") +
+          " installed globally.",
       );
       console.log("");
       toInstall.forEach((p) =>
@@ -722,8 +1254,19 @@ async function main() {
             dim(p.label),
         ),
       );
-      console.log(div2 + "\n");
 
+      // Personalized next steps
+      const installed = PACKAGES.filter((p) => isInstalled(p.name));
+      if (installed.length > 1) {
+        console.log(
+          "\n  " +
+            dim("Tip: run ") +
+            bold("sunnah --react") +
+            dim(" to generate a unified React hook for all your books"),
+        );
+      }
+
+      console.log(div2 + "\n");
       showCursor();
       process.exit(0);
     }