zammy 1.2.0 → 1.3.0

package/dist/index.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as readline from "readline";
+import * as readline4 from "readline";
 
 // src/ui/banner.ts
 import figlet from "figlet";
+import chalk3 from "chalk";
 
 // src/ui/colors.ts
 import chalk from "chalk";
@@ -180,6 +181,15 @@ var box = {
     return theme.dim(`${chars.tl}${chars.h.repeat(leftPad)} `) + title + theme.dim(` ${chars.h.repeat(rightPad)}${chars.tr}`);
   }
 };
+var progressBar = (percent, width = 30, showPercent = true) => {
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  let color = theme.success;
+  if (percent > 70) color = theme.warning;
+  if (percent > 90) color = theme.error;
+  const bar = color("\u2588".repeat(filled)) + theme.dim("\u2591".repeat(empty));
+  return showPercent ? `${bar} ${percent.toFixed(0)}%` : bar;
+};
 var bubble = {
   say: (text, width = 50) => {
     const lines = [];
@@ -227,34 +237,390 @@ var categoryIcons = {
 };
 var spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 
+// src/ui/slime-animated.ts
+import chalk2 from "chalk";
+var C = {
+  P1: "#4A235A",
+  // Darkest edge
+  P2: "#7D3C98",
+  // Dark purple
+  P3: "#9B59B6",
+  // Main purple
+  P4: "#BB8FCE",
+  // Light purple
+  P5: "#D7BDE2",
+  // Lightest highlight
+  WH: "#FFFFFF",
+  // White (sparkles, eye shine)
+  BK: "#1A1A2E",
+  // Black (eyes, mouth)
+  PK: "#E91E63",
+  // Pink (tongue)
+  YL: "#F1C40F",
+  // Yellow (stars)
+  BL: "#3498DB",
+  // Blue (tears)
+  CY: "#00CED1",
+  // Cyan (zzz)
+  RD: "#E74C3C"
+  // Red (angry)
+};
+var b = (hex) => chalk2.bgHex(hex)("  ");
+var dot = chalk2.hex(C.WH)("\xB7");
+var star = chalk2.hex(C.WH)("\u2726");
+var heart = chalk2.hex(C.PK)("\u2665");
+var z = chalk2.hex(C.CY)("z");
+var Z = chalk2.hex(C.CY)("Z");
+var eye = chalk2.bgHex(C.BK).hex(C.WH)(" \xB7");
+var shine = chalk2.bgHex(C.P3).hex(C.WH)(" \xB7");
+var shine2 = chalk2.bgHex(C.P4).hex(C.WH)("\xB7 ");
+var slimeFrames = {
+  happy: () => {
+    const { P1, P2, P3, P4, P5, BK, PK } = C;
+    return [
+      `        ${dot}                 ${dot}`,
+      `          ${b(P5)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P5)}`,
+      `        ${b(P5)}${b(P4)}${b(P3)}${shine2}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}${b(P5)}`,
+      `        ${b(P4)}${b(P3)}${eye}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${eye}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${shine}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(BK)}${b(PK)}${b(BK)}${b(P3)}${b(P3)}${b(P4)}`,
+      `          ${b(P2)}${b(P3)}${b(P3)}${b(P3)}${shine}${b(P3)}${b(P3)}${b(P2)}`,
+      `            ${b(P1)}${b(P2)}${b(P2)}${b(P2)}${b(P2)}${b(P1)}`
+    ];
+  },
+  excited: () => {
+    const { P1, P2, P3, P4, P5, BK, PK, YL } = C;
+    const starEye = chalk2.bgHex(YL).hex(C.WH)("\u2605 ");
+    return [
+      `      ${star} ${dot}     ${star}   ${dot} ${star}`,
+      `          ${b(P5)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P5)}`,
+      `        ${b(P5)}${b(P4)}${b(P3)}${shine2}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}${b(P5)}`,
+      `        ${b(P4)}${b(P3)}${starEye}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${starEye}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${shine}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(BK)}${b(PK)}${b(BK)}${b(P3)}${b(P3)}${b(P4)}`,
+      `          ${b(P2)}${b(P3)}${b(P3)}${b(P3)}${shine}${b(P3)}${b(P3)}${b(P2)}`,
+      `            ${b(P1)}${b(P2)}${b(P2)}${b(P2)}${b(P2)}${b(P1)}`
+    ];
+  },
+  love: () => {
+    const { P1, P2, P3, P4, P5, BK, PK } = C;
+    const heartEye = chalk2.bgHex(PK).hex(C.WH)("\u2665 ");
+    return [
+      `        ${heart}               ${heart}`,
+      `          ${b(P5)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P5)}`,
+      `        ${b(P5)}${b(P4)}${b(P3)}${shine2}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}${b(P5)}`,
+      `        ${b(P4)}${b(P3)}${heartEye}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${heartEye}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${shine}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(BK)}${b(PK)}${b(BK)}${b(P3)}${b(P3)}${b(P4)}`,
+      `          ${b(P2)}${b(P3)}${b(P3)}${b(P3)}${shine}${b(P3)}${b(P3)}${b(P2)}`,
+      `            ${b(P1)}${b(P2)}${b(P2)}${b(P2)}${b(P2)}${b(P1)}`
+    ];
+  },
+  sleepy: () => {
+    const { P1, P2, P3, P4, P5, BK } = C;
+    const closedEye = chalk2.bgHex(P3).hex(BK)("\u2500\u2500");
+    return [
+      `                        ${z} ${z} ${Z}`,
+      `          ${b(P5)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P5)}`,
+      `        ${b(P5)}${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}${b(P5)}`,
+      `        ${b(P4)}${b(P3)}${closedEye}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${closedEye}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(BK)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `          ${b(P2)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P2)}`,
+      `            ${b(P1)}${b(P2)}${b(P2)}${b(P2)}${b(P2)}${b(P1)}`
+    ];
+  },
+  thinking: () => {
+    const { P1, P2, P3, P4, P5, BK, YL } = C;
+    const thinkEye = chalk2.bgHex(C.BK).hex(C.WH)(" \xB7");
+    const lookUpEye = chalk2.bgHex(C.BK).hex(C.WH)("\xB7 ");
+    return [
+      `                          ${chalk2.hex(YL)("?")}`,
+      `          ${b(P5)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P5)}`,
+      `        ${b(P5)}${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}${b(P5)}`,
+      `        ${b(P4)}${b(P3)}${thinkEye}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${lookUpEye}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(BK)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `          ${b(P2)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P2)}`,
+      `            ${b(P1)}${b(P2)}${b(P2)}${b(P2)}${b(P2)}${b(P1)}`
+    ];
+  },
+  surprised: () => {
+    const { P1, P2, P3, P4, P5, BK, YL } = C;
+    const bigEye = chalk2.bgHex(BK).hex(C.WH)("\u25C9 ");
+    return [
+      `          ${chalk2.hex(YL)("!!")}`,
+      `          ${b(P5)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P5)}`,
+      `        ${b(P5)}${b(P4)}${b(P3)}${shine2}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}${b(P5)}`,
+      `        ${b(P4)}${b(P3)}${bigEye}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${bigEye}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${shine}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(BK)}${b(BK)}${b(BK)}${b(P3)}${b(P3)}${b(P4)}`,
+      `          ${b(P2)}${b(P3)}${b(P3)}${b(P3)}${shine}${b(P3)}${b(P3)}${b(P2)}`,
+      `            ${b(P1)}${b(P2)}${b(P2)}${b(P2)}${b(P2)}${b(P1)}`
+    ];
+  },
+  sad: () => {
+    const { P1, P2, P3, P4, P5, BK, BL } = C;
+    const sadEye = chalk2.bgHex(BK).hex(C.WH)(" \xB7");
+    const tear = chalk2.bgHex(BL)("  ");
+    return [
+      `        ${dot}       ${dot}       ${dot}`,
+      `          ${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${sadEye}${tear}${b(P3)}${b(P3)}${tear}${sadEye}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(BK)}${b(BK)}${b(BK)}${b(P3)}${b(P3)}${b(P4)}`,
+      `          ${b(P2)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P2)}`,
+      `            ${b(P1)}${b(P2)}${b(P2)}${b(P2)}${b(P2)}${b(P1)}`
+    ];
+  },
+  wink: () => {
+    const { P1, P2, P3, P4, P5, BK, PK } = C;
+    const winkEye = chalk2.bgHex(P3).hex(BK)("> ");
+    return [
+      `        ${star}               ${dot}`,
+      `          ${b(P5)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P5)}`,
+      `        ${b(P5)}${b(P4)}${b(P3)}${shine2}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}${b(P5)}`,
+      `        ${b(P4)}${b(P3)}${eye}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${winkEye}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${shine}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(BK)}${b(PK)}${b(BK)}${b(P3)}${b(P3)}${b(P4)}`,
+      `          ${b(P2)}${b(P3)}${b(P3)}${b(P3)}${shine}${b(P3)}${b(P3)}${b(P2)}`,
+      `            ${b(P1)}${b(P2)}${b(P2)}${b(P2)}${b(P2)}${b(P1)}`
+    ];
+  },
+  angry: () => {
+    const { P1, P2, P3, P4, BK, RD } = C;
+    const angryEye = chalk2.bgHex(BK).hex(RD)("> ");
+    const angryEye2 = chalk2.bgHex(BK).hex(RD)(" <");
+    return [
+      `          ${chalk2.hex(RD)("# @!")}`,
+      `          ${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${angryEye}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${angryEye2}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P4)}`,
+      `        ${b(P4)}${b(P3)}${b(P3)}${b(P3)}${b(BK)}${b(BK)}${b(BK)}${b(P3)}${b(P3)}${b(P4)}`,
+      `          ${b(P2)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P3)}${b(P2)}`,
+      `            ${b(P1)}${b(P2)}${b(P2)}${b(P2)}${b(P2)}${b(P1)}`
+    ];
+  }
+};
+var greetings = [
+  "Hiii~! I'm Zammy!",
+  "Ready to get stuff done?",
+  "*bounces* What's the plan?",
+  "Type / to see commands!",
+  "*jiggles excitedly* Let's go!",
+  "*sparkles* Hi friend!"
+];
+var lateNightGreetings = [
+  "*yawns* Burning the midnight oil?",
+  "zzZ... oh! You're still up?",
+  "*sleepy bounce* Late night coding?",
+  "The best code happens at 3am~"
+];
+var morningGreetings = [
+  "*stretches* Good morning~!",
+  "Rise and shine!",
+  "*bounces awake* New day!",
+  "Morning! Coffee first?"
+];
+function getGreeting() {
+  const hour = (/* @__PURE__ */ new Date()).getHours();
+  if (hour >= 0 && hour < 5) {
+    return lateNightGreetings[Math.floor(Math.random() * lateNightGreetings.length)];
+  } else if (hour >= 5 && hour < 12) {
+    return morningGreetings[Math.floor(Math.random() * morningGreetings.length)];
+  }
+  return greetings[Math.floor(Math.random() * greetings.length)];
+}
+function getStartupMood() {
+  const hour = (/* @__PURE__ */ new Date()).getHours();
+  if (hour >= 0 && hour < 5) return "sleepy";
+  return "happy";
+}
+var miniSlime = {
+  happy: chalk2.hex(C.P3)("(") + chalk2.hex(C.BK)("\u25D5") + chalk2.hex(C.P3)("\u1D17") + chalk2.hex(C.BK)("\u25D5") + chalk2.hex(C.P3)(")"),
+  excited: chalk2.hex(C.P3)("(") + chalk2.hex(C.YL)("\u2605") + chalk2.hex(C.P3)("\u1D17") + chalk2.hex(C.YL)("\u2605") + chalk2.hex(C.P3)(")"),
+  love: chalk2.hex(C.P3)("(") + chalk2.hex(C.PK)("\u2665") + chalk2.hex(C.P3)("\u1D17") + chalk2.hex(C.PK)("\u2665") + chalk2.hex(C.P3)(")"),
+  sleepy: chalk2.hex(C.P3)("(") + chalk2.hex(C.BK)("\u2013") + chalk2.hex(C.P3)("\u03C9") + chalk2.hex(C.BK)("\u2013") + chalk2.hex(C.P3)(") zZ"),
+  sad: chalk2.hex(C.P3)("(") + chalk2.hex(C.BK)("\u25D5") + chalk2.hex(C.P3)("\uFE35") + chalk2.hex(C.BK)("\u25D5") + chalk2.hex(C.P3)(")"),
+  surprised: chalk2.hex(C.P3)("(") + chalk2.hex(C.BK)("\u25CE") + chalk2.hex(C.P3)("\u25CB") + chalk2.hex(C.BK)("\u25CE") + chalk2.hex(C.P3)(")!"),
+  wink: chalk2.hex(C.P3)("(") + chalk2.hex(C.BK)("\u25D5") + chalk2.hex(C.P3)("\u1D17") + chalk2.hex(C.BK)(">") + chalk2.hex(C.P3)(")"),
+  thinking: chalk2.hex(C.P3)("(") + chalk2.hex(C.BK)("\u25D5") + chalk2.hex(C.P3)("\uFF5E") + chalk2.hex(C.BK)("\u25D4") + chalk2.hex(C.P3)(")"),
+  angry: chalk2.hex(C.P3)("(") + chalk2.hex(C.RD)(">") + chalk2.hex(C.P3)("_") + chalk2.hex(C.RD)("<") + chalk2.hex(C.P3)(")")
+};
+var validMoods = Object.keys(slimeFrames);
+function react(mood, message) {
+  const slime = miniSlime[mood] || miniSlime.happy;
+  if (message) {
+    console.log(`  ${slime} ${message}`);
+  } else {
+    console.log(`  ${slime}`);
+  }
+}
+var MIN_WIDTH_FOR_MASCOT = 50;
+function showMascot(mood) {
+  const termWidth = process.stdout.columns || 80;
+  if (termWidth < MIN_WIDTH_FOR_MASCOT) {
+    react(mood);
+    return;
+  }
+  const frameFunc = slimeFrames[mood];
+  if (frameFunc) {
+    const art = frameFunc();
+    console.log("");
+    art.forEach((line) => console.log("  " + line));
+    console.log("");
+  }
+}
+function getMoodFromText(text) {
+  const lower = text.toLowerCase();
+  if (/\b(thanks|thank you|love|love you|thx|ty|<3|heart)\b/.test(lower)) {
+    return "love";
+  }
+  if (/\b(awesome|amazing|wow|cool|nice|great|perfect|yay|woohoo|!\s*$)\b/.test(lower)) {
+    return "excited";
+  }
+  if (/\b(tired|sleepy|zzz|night|late|exhausted)\b/.test(lower)) {
+    return "sleepy";
+  }
+  if (/\b(angry|mad|hate|stupid|wtf|damn|crap|sucks|ugh|argh|grr)\b|:\(/.test(lower)) {
+    return "angry";
+  }
+  if (/\b(sad|sorry|fail|broke|wrong)\b/.test(lower)) {
+    return "sad";
+  }
+  if (/\b(hmm|think|wonder|maybe|idk|not sure|confused|\?$)\b/.test(lower)) {
+    return "thinking";
+  }
+  return null;
+}
+
 // src/ui/banner.ts
-async function displayBanner() {
-  return new Promise((resolve3) => {
+var C2 = {
+  // Purple gradient (light to dark)
+  P1: "#4A235A",
+  // Darkest edge
+  P2: "#7D3C98",
+  // Dark purple
+  P3: "#9B59B6",
+  // Main purple
+  P4: "#BB8FCE",
+  // Light purple
+  P5: "#D7BDE2",
+  // Lightest
+  // Accents
+  WH: "#FFFFFF",
+  // White (sparkles, eye highlight)
+  BK: "#1A1A2E",
+  // Black (eyes, mouth)
+  PK: "#E91E63"
+  // Pink (tongue)
+};
+var b2 = (hex) => chalk3.bgHex(hex)("  ");
+var dot2 = chalk3.hex(C2.WH)("\xB7");
+function getSlimeLines(isBlinking, _mood) {
+  const { P1, P2, P3, P4, P5, WH, BK, PK } = C2;
+  const openEye = chalk3.bgHex(BK).hex(WH)(" \xB7");
+  const closedEye = chalk3.bgHex(P3).hex(BK)("\u2500\u2500");
+  const eyeL = isBlinking ? closedEye : openEye;
+  const eyeR = isBlinking ? closedEye : openEye;
+  const shine3 = chalk3.bgHex(P3).hex(WH)(" \xB7");
+  const shine22 = chalk3.bgHex(P4).hex(WH)("\xB7 ");
+  const miniBlob = `${b2(P3)}`;
+  return [
+    `        ${dot2}                 ${dot2}`,
+    `          ${b2(P5)}${b2(P4)}${b2(P4)}${b2(P4)}${b2(P4)}${b2(P4)}${b2(P4)}${b2(P5)}`,
+    `        ${b2(P5)}${b2(P4)}${b2(P3)}${shine22}${b2(P3)}${b2(P3)}${b2(P3)}${b2(P3)}${b2(P4)}${b2(P5)}`,
+    `        ${b2(P4)}${b2(P3)}${eyeL}${b2(P3)}${b2(P3)}${b2(P3)}${b2(P3)}${eyeR}${b2(P3)}${b2(P4)}`,
+    `        ${b2(P4)}${b2(P3)}${b2(P3)}${b2(P3)}${shine3}${b2(P3)}${b2(P3)}${b2(P3)}${b2(P3)}${b2(P4)}`,
+    `        ${b2(P4)}${b2(P3)}${b2(P3)}${b2(P3)}${b2(BK)}${b2(PK)}${b2(BK)}${b2(P3)}${b2(P3)}${b2(P4)}`,
+    `          ${b2(P2)}${b2(P3)}${b2(P3)}${b2(P3)}${shine3}${b2(P3)}${b2(P3)}${b2(P2)}`,
+    `            ${b2(P1)}${b2(P2)}${b2(P2)}${b2(P2)}${b2(P2)}${b2(P1)}    ${miniBlob}`
+  ];
+}
+var MIN_WIDTH_FOR_MASCOT2 = 90;
+var MIN_WIDTH_FOR_FULL_LOGO = 55;
+var MIN_WIDTH_FOR_COMPACT = 30;
+async function displayBanner(simple = false) {
+  return new Promise((resolve6) => {
+    const termWidth = process.stdout.columns || 80;
     figlet("ZAMMY", {
       font: "ANSI Shadow",
       horizontalLayout: "default"
-    }, (err, data) => {
+    }, async (err, data) => {
       console.log("");
-      if (err || !data) {
-        console.log(theme.gradient("  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557"));
-        console.log(theme.gradient("  \u255A\u2550\u2550\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D"));
-        console.log(theme.gradient("    \u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2554\u255D "));
-        console.log(theme.gradient("   \u2588\u2588\u2588\u2554\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u255A\u2588\u2588\u2554\u255D  "));
-        console.log(theme.gradient("  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551   \u2588\u2588\u2551   "));
-        console.log(theme.gradient("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D   \u255A\u2550\u255D   "));
+      const greeting = getGreeting();
+      const mood = getStartupMood();
+      if (termWidth < MIN_WIDTH_FOR_COMPACT) {
+        console.log(theme.gradient("  ZAMMY"));
+        console.log(theme.secondary(`  "${greeting}"`));
+        console.log(theme.dim("  Type /help for commands"));
+        console.log("");
+        resolve6();
+        return;
+      }
+      let figletLines = [];
+      if (err || !data || termWidth < MIN_WIDTH_FOR_FULL_LOGO) {
+        if (termWidth < MIN_WIDTH_FOR_FULL_LOGO) {
+          figletLines = [
+            "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557",
+            "\u2551    Z A M M Y          \u2551",
+            "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+          ];
+        } else {
+          figletLines = [
+            "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557",
+            "\u255A\u2550\u2550\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D",
+            "  \u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2554\u255D ",
+            " \u2588\u2588\u2588\u2554\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u255A\u2588\u2588\u2554\u255D  ",
+            "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551   \u2588\u2588\u2551   ",
+            "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D   \u255A\u2550\u255D   "
+          ];
+        }
       } else {
-        data.split("\n").forEach((line) => {
-          console.log(theme.gradient(line));
-        });
+        figletLines = data.split("\n").filter((line) => line.trim());
       }
+      const showMascot2 = !simple && termWidth >= MIN_WIDTH_FOR_MASCOT2;
+      if (!showMascot2) {
+        figletLines.forEach((line) => console.log("  " + theme.gradient(line)));
+        console.log("");
+        console.log(theme.secondary(`  "${greeting}"`));
+        console.log("");
+        console.log(theme.dim(`  ${symbols.arrow} Type ${theme.primary("/")} to browse commands or ${theme.primary("/help")} for full list`));
+        console.log(theme.dim(`  ${symbols.arrow} Shell commands start with ${theme.primary("!")} (e.g., ${theme.primary("!ls")}, ${theme.primary("!git")})`));
+        console.log("");
+        resolve6();
+        return;
+      }
+      const figletWidth = 50;
+      const paddedFiglet = figletLines.map((line) => line.padEnd(figletWidth));
+      const blinkSequence = [false, false, false, true, false, false];
+      const frameTime = 180;
+      process.stdout.write("\x1B[?25l");
+      for (let frame = 0; frame < blinkSequence.length; frame++) {
+        const isBlinking = blinkSequence[frame];
+        const slimeLines = getSlimeLines(isBlinking, mood);
+        if (frame > 0) {
+          const totalLines = Math.max(paddedFiglet.length, slimeLines.length) + 1;
+          process.stdout.write(`\x1B[${totalLines}A`);
+        }
+        const maxLines = Math.max(paddedFiglet.length, slimeLines.length);
+        for (let i = 0; i < maxLines; i++) {
+          const figLine = paddedFiglet[i] || "".padEnd(figletWidth);
+          const slimeLine = slimeLines[i] || "";
+          console.log("  " + theme.gradient(figLine) + " " + slimeLine);
+        }
+        console.log("");
+        await new Promise((r) => setTimeout(r, frameTime));
+      }
+      process.stdout.write("\x1B[?25h");
+      console.log(theme.secondary(`  "${greeting}"`));
       console.log("");
-      console.log(`  ${symbols.sparkle} ${theme.secondary("Your slice-of-life terminal companion")} ${symbols.sparkle}`);
-      console.log("");
-      console.log(theme.dim(`  ${symbols.arrow} Type ${theme.primary("/")} to browse commands (use ${theme.primary("\u2191\u2193")} to navigate, ${theme.primary("Tab")} to select)`));
-      console.log(theme.dim(`  ${symbols.arrow} Type ${theme.primary("/help")} for full command list`));
-      console.log(theme.dim(`  ${symbols.arrow} Shell commands start with ${theme.primary("!")} (e.g., ${theme.primary("!ls")}, ${theme.primary("!cd")})`));
+      console.log(theme.dim(`  ${symbols.arrow} Type ${theme.primary("/")} to browse commands or ${theme.primary("/help")} for full list`));
+      console.log(theme.dim(`  ${symbols.arrow} Shell commands start with ${theme.primary("!")} (e.g., ${theme.primary("!ls")}, ${theme.primary("!git")})`));
       console.log("");
-      resolve3();
+      resolve6();
     });
   });
 }
@@ -267,7 +633,17 @@ function getPrompt() {
 // src/commands/registry.ts
 var commands = /* @__PURE__ */ new Map();
 function registerCommand(command) {
-  commands.set(command.name, command);
+  commands.set(command.name, { ...command, source: "core" });
+}
+function registerPluginCommand(command, pluginName) {
+  commands.set(command.name, { ...command, source: "plugin", pluginName });
+}
+function unregisterPluginCommands(pluginName) {
+  for (const [name, cmd] of commands.entries()) {
+    if (cmd.source === "plugin" && cmd.pluginName === pluginName) {
+      commands.delete(name);
+    }
+  }
 }
 function getCommand(name) {
   return commands.get(name);
@@ -275,14 +651,29 @@ function getCommand(name) {
 function getAllCommands() {
   return Array.from(commands.values());
 }
+function getPluginCommands() {
+  return Array.from(commands.values()).filter((cmd) => cmd.source === "plugin");
+}
+function checkCommandConflict(name) {
+  const existing = commands.get(name);
+  if (!existing) {
+    return { exists: false };
+  }
+  return {
+    exists: true,
+    source: existing.source,
+    pluginName: existing.pluginName
+  };
+}
 
 // src/commands/utilities/help.ts
 var categories = {
   "Utilities": ["help", "exit", "calc", "password", "stats", "time", "countdown", "timer", "todo", "history"],
-  "Fun": ["joke", "quote", "fortune", "dice", "flip", "pomodoro"],
+  "Fun": ["joke", "quote", "fortune", "dice", "flip", "pomodoro", "zammy"],
   "Creative": ["asciiart", "figlet", "lorem", "color"],
   "Dev": ["hash", "uuid", "encode"],
-  "Info": ["weather"]
+  "Info": ["weather"],
+  "System": ["plugin"]
 };
 registerCommand({
   name: "help",
@@ -335,8 +726,24 @@ registerCommand({
       }
       console.log("");
     }
+    const pluginCmds = getPluginCommands();
+    if (pluginCmds.length > 0) {
+      console.log(`  ${symbols.gear} ${theme.b.secondary("Plugins")}`);
+      console.log(theme.dim("  " + "\u2500".repeat(46)));
+      for (const cmd of pluginCmds) {
+        const paddedName = cmd.name.padEnd(maxNameLength + 2);
+        const pluginBadge = cmd.pluginName ? theme.dim(`[${cmd.pluginName}]`) : "";
+        console.log(
+          `    ${theme.command("/" + paddedName)} ${theme.dim("\u2502")} ${theme.dim(cmd.description)} ${pluginBadge}`
+        );
+      }
+      console.log("");
+    }
     const categorizedNames = Object.values(categories).flat();
-    const uncategorized = commands2.filter((c) => !categorizedNames.includes(c.name));
+    const pluginCmdNames = pluginCmds.map((c) => c.name);
+    const uncategorized = commands2.filter(
+      (c) => !categorizedNames.includes(c.name) && !pluginCmdNames.includes(c.name) && c.source === "core"
+    );
     if (uncategorized.length > 0) {
       console.log(`  ${symbols.folder} ${theme.b.secondary("Other")}`);
       console.log(theme.dim("  " + "\u2500".repeat(46)));
@@ -785,7 +1192,7 @@ registerCommand({
     console.log("");
     let remaining = totalSeconds;
     let spinnerIndex = 0;
-    return new Promise((resolve3) => {
+    return new Promise((resolve6) => {
       const interval = setInterval(() => {
         process.stdout.write("\r\x1B[K");
         if (remaining <= 0) {
@@ -793,7 +1200,7 @@ registerCommand({
           console.log(`  ${symbols.sparkle} ${theme.success("TIME'S UP!")} ${symbols.sparkle}`);
           console.log("");
           process.stdout.write("\x07");
-          resolve3();
+          resolve6();
           return;
         }
         const spinner = spinnerFrames[spinnerIndex % spinnerFrames.length];
@@ -1111,58 +1518,368 @@ registerCommand({
   }
 });
 
+// src/handlers/utilities/env.ts
+function getAllEnvVars() {
+  return Object.entries(process.env).filter(([, value]) => value !== void 0).map(([name, value]) => ({ name, value })).sort((a, b3) => a.name.localeCompare(b3.name));
+}
+function getEnvVar(name) {
+  const exactMatch = process.env[name];
+  if (exactMatch !== void 0) return exactMatch;
+  const upperName = name.toUpperCase();
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.toUpperCase() === upperName) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function searchEnvVars(query) {
+  const lowerQuery = query.toLowerCase();
+  return getAllEnvVars().filter(
+    (env) => env.name.toLowerCase().includes(lowerQuery) || env.value.toLowerCase().includes(lowerQuery)
+  );
+}
+function getPathEntries() {
+  const pathVar = process.env.PATH || process.env.Path || "";
+  const separator = process.platform === "win32" ? ";" : ":";
+  return pathVar.split(separator).filter(Boolean);
+}
+
+// src/commands/utilities/env.ts
+registerCommand({
+  name: "env",
+  description: "View environment variables",
+  usage: "/env [name|search|path]",
+  async execute(args2) {
+    const action = args2[0];
+    console.log("");
+    if (!action) {
+      const vars = getAllEnvVars();
+      console.log(`  ${symbols.sparkle} ${theme.gradient("ENVIRONMENT VARIABLES")} ${theme.dim(`(${vars.length})`)}`);
+      console.log("");
+      for (const env of vars.slice(0, 30)) {
+        const displayValue = env.value.length > 50 ? env.value.slice(0, 47) + "..." : env.value;
+        console.log(`  ${theme.primary(env.name.padEnd(20))} ${theme.dim("=")} ${displayValue}`);
+      }
+      if (vars.length > 30) {
+        console.log("");
+        console.log(`  ${theme.dim(`... and ${vars.length - 30} more. Use /env search <query> to filter.`)}`);
+      }
+      console.log("");
+      return;
+    }
+    if (action.toLowerCase() === "path") {
+      const paths = getPathEntries();
+      console.log(`  ${symbols.sparkle} ${theme.gradient("PATH ENTRIES")} ${theme.dim(`(${paths.length})`)}`);
+      console.log("");
+      paths.forEach((p, i) => {
+        console.log(`  ${theme.dim(`${(i + 1).toString().padStart(2)}.`)} ${theme.primary(p)}`);
+      });
+      console.log("");
+      return;
+    }
+    if (action.toLowerCase() === "search" && args2[1]) {
+      const query = args2.slice(1).join(" ");
+      const results = searchEnvVars(query);
+      console.log(`  ${symbols.sparkle} ${theme.gradient(`SEARCH: "${query}"`)} ${theme.dim(`(${results.length} matches)`)}`);
+      console.log("");
+      if (results.length === 0) {
+        console.log(`  ${theme.dim("No matches found")}`);
+      } else {
+        for (const env of results) {
+          const displayValue = env.value.length > 50 ? env.value.slice(0, 47) + "..." : env.value;
+          console.log(`  ${theme.primary(env.name.padEnd(20))} ${theme.dim("=")} ${displayValue}`);
+        }
+      }
+      console.log("");
+      return;
+    }
+    const value = getEnvVar(action);
+    if (value !== void 0) {
+      console.log(`  ${theme.primary(action)} ${theme.dim("=")}`);
+      console.log("");
+      if (value.includes(process.platform === "win32" ? ";" : ":") && value.length > 100) {
+        const separator = process.platform === "win32" ? ";" : ":";
+        const parts = value.split(separator);
+        parts.forEach((p, i) => {
+          console.log(`  ${theme.dim(`${(i + 1).toString().padStart(2)}.`)} ${p}`);
+        });
+      } else {
+        console.log(`  ${theme.success(value)}`);
+      }
+    } else {
+      console.log(`  ${symbols.cross} ${theme.error(`Environment variable not found: ${action}`)}`);
+    }
+    console.log("");
+  }
+});
+
+// src/handlers/utilities/size.ts
+import { statSync, readdirSync, existsSync as existsSync3 } from "fs";
+import { join as join3, basename } from "path";
+function formatBytes2(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const size = bytes / Math.pow(1024, i);
+  return `${size.toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}
+function getSize(path) {
+  if (!existsSync3(path)) return null;
+  try {
+    const stats = statSync(path);
+    if (stats.isFile()) {
+      return {
+        path,
+        name: basename(path),
+        size: stats.size,
+        isDirectory: false
+      };
+    }
+    if (stats.isDirectory()) {
+      return getDirSize(path);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getDirSize(dirPath) {
+  const children = [];
+  let totalSize = 0;
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = join3(dirPath, entry.name);
+      try {
+        if (entry.isFile()) {
+          const stats = statSync(entryPath);
+          totalSize += stats.size;
+          children.push({
+            path: entryPath,
+            name: entry.name,
+            size: stats.size,
+            isDirectory: false
+          });
+        } else if (entry.isDirectory()) {
+          if (["node_modules", ".git", "dist", "build", ".next", "coverage"].includes(entry.name)) {
+            const subSize = getQuickDirSize(entryPath);
+            totalSize += subSize;
+            children.push({
+              path: entryPath,
+              name: entry.name,
+              size: subSize,
+              isDirectory: true
+            });
+          } else {
+            const subInfo = getDirSize(entryPath);
+            totalSize += subInfo.size;
+            children.push(subInfo);
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  children.sort((a, b3) => b3.size - a.size);
+  return {
+    path: dirPath,
+    name: basename(dirPath),
+    size: totalSize,
+    isDirectory: true,
+    children
+  };
+}
+function getQuickDirSize(dirPath) {
+  let totalSize = 0;
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = join3(dirPath, entry.name);
+      try {
+        if (entry.isFile()) {
+          totalSize += statSync(entryPath).size;
+        } else if (entry.isDirectory()) {
+          totalSize += getQuickDirSize(entryPath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return totalSize;
+}
+function findLargestFiles(dirPath, count = 10) {
+  const allFiles = [];
+  function collectFiles(dir) {
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = join3(dir, entry.name);
+        try {
+          if (entry.isFile()) {
+            const stats = statSync(entryPath);
+            allFiles.push({
+              path: entryPath,
+              name: entry.name,
+              size: stats.size,
+              isDirectory: false
+            });
+          } else if (entry.isDirectory()) {
+            if (!["node_modules", ".git"].includes(entry.name)) {
+              collectFiles(entryPath);
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  collectFiles(dirPath);
+  allFiles.sort((a, b3) => b3.size - a.size);
+  return allFiles.slice(0, count);
+}
+
+// src/commands/utilities/size.ts
+import { resolve } from "path";
+registerCommand({
+  name: "size",
+  description: "Analyze file/folder sizes",
+  usage: "/size [path] [--top N]",
+  async execute(args2) {
+    const targetPath = args2[0] || ".";
+    const absPath = resolve(targetPath);
+    const topIndex = args2.indexOf("--top");
+    const showTop = topIndex !== -1 ? parseInt(args2[topIndex + 1]) || 10 : 0;
+    console.log("");
+    if (showTop > 0) {
+      console.log(`  ${symbols.sparkle} ${theme.gradient("LARGEST FILES")}`);
+      console.log(`  ${theme.dim(`in ${absPath}`)}`);
+      console.log("");
+      const largestFiles = findLargestFiles(absPath, showTop);
+      if (largestFiles.length === 0) {
+        console.log(`  ${theme.dim("No files found")}`);
+      } else {
+        const maxSize = largestFiles[0].size;
+        for (let i = 0; i < largestFiles.length; i++) {
+          const file = largestFiles[i];
+          const percent = file.size / maxSize * 100;
+          const bar = progressBar(percent, 20);
+          const relativePath = file.path.replace(absPath, ".").replace(/\\/g, "/");
+          console.log(
+            `  ${theme.dim(`${(i + 1).toString().padStart(2)}.`)} ${bar} ${theme.primary(formatBytes2(file.size).padStart(10))} ${relativePath}`
+          );
+        }
+      }
+      console.log("");
+      return;
+    }
+    const info = getSize(absPath);
+    if (!info) {
+      console.log(`  ${symbols.cross} ${theme.error(`Path not found: ${absPath}`)}`);
+      console.log("");
+      return;
+    }
+    console.log(`  ${symbols.sparkle} ${theme.gradient("SIZE ANALYSIS")}`);
+    console.log(`  ${theme.dim(absPath)}`);
+    console.log("");
+    if (!info.isDirectory) {
+      console.log(`  ${theme.primary(info.name)}: ${theme.success(formatBytes2(info.size))}`);
+    } else {
+      console.log(`  ${theme.secondary("Total:")} ${theme.success(formatBytes2(info.size))}`);
+      console.log("");
+      if (info.children && info.children.length > 0) {
+        const maxSize = info.children[0].size;
+        const displayCount = Math.min(15, info.children.length);
+        for (let i = 0; i < displayCount; i++) {
+          const child = info.children[i];
+          const percent = child.size / maxSize * 100;
+          const bar = progressBar(percent, 15);
+          const icon = child.isDirectory ? symbols.folder : symbols.bullet;
+          console.log(
+            `  ${bar} ${theme.primary(formatBytes2(child.size).padStart(10))} ${icon} ${child.name}`
+          );
+        }
+        if (info.children.length > displayCount) {
+          console.log("");
+          console.log(`  ${theme.dim(`... and ${info.children.length - displayCount} more items`)}`);
+        }
+      } else {
+        console.log(`  ${theme.dim("Directory is empty")}`);
+      }
+    }
+    console.log("");
+    console.log(`  ${theme.dim("Tip: /size . --top 10 shows largest files")}`);
+    console.log("");
+  }
+});
+
 // src/commands/fun/joke.ts
 var fallbackJokes = [
   { setup: "Why do programmers prefer dark mode?", punchline: "Because light attracts bugs!" },
   { setup: "Why do Java developers wear glasses?", punchline: "Because they can't C#!" },
   { setup: "A SQL query walks into a bar, walks up to two tables and asks...", punchline: "Can I join you?" },
   { setup: "Why did the developer go broke?", punchline: "Because he used up all his cache!" },
-  { setup: "How many programmers does it take to change a light bulb?", punchline: "None, that's a hardware problem!" }
+  { setup: "How many programmers does it take to change a light bulb?", punchline: "None, that's a hardware problem!" },
+  { setup: "Why do programmers hate nature?", punchline: "It has too many bugs!" },
+  { setup: "What's a programmer's favorite hangout place?", punchline: "Foo Bar!" },
+  { setup: "Why was the JavaScript developer sad?", punchline: "Because he didn't Node how to Express himself!" },
+  { setup: "What do you call a computer that sings?", punchline: "A-Dell!" },
+  { setup: "Why did the developer quit his job?", punchline: "Because he didn't get arrays (a raise)!" }
 ];
+async function fetchJoke() {
+  try {
+    const response = await fetch("https://v2.jokeapi.dev/joke/Programming?type=twopart&safe-mode", {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (!data.error && data.setup && data.delivery) {
+        return { setup: data.setup, punchline: data.delivery };
+      }
+    }
+  } catch {
+  }
+  try {
+    const response = await fetch("https://official-joke-api.appspot.com/jokes/programming/random", {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (data && data[0]) {
+        return { setup: data[0].setup, punchline: data[0].punchline };
+      }
+    }
+  } catch {
+  }
+  return fallbackJokes[Math.floor(Math.random() * fallbackJokes.length)];
+}
 registerCommand({
   name: "joke",
-  description: "Get a random joke",
+  description: "Get a random programming joke",
   usage: "/joke",
   async execute(_args) {
     console.log("");
     console.log(`  ${symbols.dice} ${theme.sunset("Getting a joke...")}`);
-    try {
-      const response = await fetch("https://official-joke-api.appspot.com/random_joke", {
-        signal: AbortSignal.timeout(3e3)
-      });
-      let joke;
-      if (!response.ok) {
-        joke = fallbackJokes[Math.floor(Math.random() * fallbackJokes.length)];
-      } else {
-        joke = await response.json();
-      }
-      process.stdout.write("\x1B[1A\x1B[2K");
-      console.log("");
-      console.log(bubble.say(joke.setup, 55));
-      console.log(`       ${symbols.sparkle}`);
-      await new Promise((resolve3) => setTimeout(resolve3, 1500));
-      console.log("");
-      console.log(`  ${theme.gold("  \u2726")} ${theme.b.success(joke.punchline)} ${theme.gold("\u2726")}`);
-      console.log("");
-      console.log(`  ${theme.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`);
-      console.log(`  ${symbols.dice} ${theme.dim("Run /joke again for another!")}`);
-      console.log("");
-    } catch (error) {
-      process.stdout.write("\x1B[1A\x1B[2K");
-      const joke = fallbackJokes[Math.floor(Math.random() * fallbackJokes.length)];
-      console.log("");
-      console.log(bubble.say(joke.setup, 55));
-      console.log(`       ${symbols.sparkle}`);
-      await new Promise((resolve3) => setTimeout(resolve3, 1500));
-      console.log("");
-      console.log(`  ${theme.gold("  \u2726")} ${theme.b.success(joke.punchline)} ${theme.gold("\u2726")}`);
-      console.log("");
-    }
+    const joke = await fetchJoke();
+    process.stdout.write("\x1B[1A\x1B[2K");
+    console.log("");
+    console.log(bubble.say(joke.setup, 55));
+    console.log(`       ${symbols.sparkle}`);
+    await new Promise((resolve6) => setTimeout(resolve6, 1500));
+    console.log("");
+    console.log(`  ${theme.gold("  \u2726")} ${theme.b.success(joke.punchline)} ${theme.gold("\u2726")}`);
+    console.log("");
+    console.log(`  ${theme.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`);
+    console.log(`  ${symbols.dice} ${theme.dim("Run /joke again for another!")}`);
+    console.log("");
   }
 });
 
 // src/commands/fun/quote.ts
-var quotes = [
+var fallbackQuotes = [
   { text: "The only way to do great work is to love what you do.", author: "Steve Jobs" },
   { text: "Code is like humor. When you have to explain it, it's bad.", author: "Cory House" },
   { text: "First, solve the problem. Then, write the code.", author: "John Johnson" },
@@ -1179,6 +1896,33 @@ var quotes = [
   { text: "There are only two hard things in Computer Science: cache invalidation and naming things.", author: "Phil Karlton" },
   { text: "The best time to plant a tree was 20 years ago. The second best time is now.", author: "Chinese Proverb" }
 ];
+async function fetchQuote() {
+  try {
+    const response = await fetch("https://zenquotes.io/api/random", {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (data && data[0]) {
+        return { text: data[0].q, author: data[0].a };
+      }
+    }
+  } catch {
+  }
+  try {
+    const response = await fetch("https://api.quotable.io/random", {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (data && data.content) {
+        return { text: data.content, author: data.author };
+      }
+    }
+  } catch {
+  }
+  return fallbackQuotes[Math.floor(Math.random() * fallbackQuotes.length)];
+}
 function wrapText(text, maxWidth) {
   const words = text.split(" ");
   const lines = [];
@@ -1199,7 +1943,10 @@ registerCommand({
   description: "Get an inspirational quote",
   usage: "/quote",
   async execute(_args) {
-    const quote = quotes[Math.floor(Math.random() * quotes.length)];
+    console.log("");
+    console.log(`  ${symbols.sparkle} ${theme.dim("Fetching wisdom...")}`);
+    const quote = await fetchQuote();
+    process.stdout.write("\x1B[1A\x1B[2K\x1B[1A\x1B[2K");
     const wrapped = wrapText(quote.text, 55);
     console.log("");
     console.log(`  ${theme.dim("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E")}`);
@@ -1405,7 +2152,7 @@ function rollDice(count = 1, sides = 6) {
     count: safeCount,
     sides: safeSides,
     rolls,
-    total: rolls.reduce((a, b) => a + b, 0),
+    total: rolls.reduce((a, b3) => a + b3, 0),
     isStandardD6: safeSides === 6 && safeCount <= 3
   };
 }
@@ -1655,18 +2402,110 @@ registerCommand({
   }
 });
 
-// src/commands/creative/asciiart.ts
-import Jimp from "jimp";
-import { existsSync as existsSync3 } from "fs";
-import { resolve } from "path";
-var CHAR_RAMPS = {
-  // Standard - 10 levels, balanced
-  standard: " .:-=+*#%@",
-  // Detailed - 16 levels, more gradation
-  detailed: " .'`^\",:;Il!i><~+_-?][}{1)(|/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$",
-  // Block characters - uses Unicode block elements for smoother look
-  blocks: " \u2591\u2592\u2593\u2588",
-  // Simple - 5 levels for cleaner output
+// src/commands/fun/zammy.ts
+var MIN_WIDTH_FOR_MASCOT3 = 50;
+var MIN_WIDTH_FOR_ASCII = 70;
+var asciiMascot = `
+                       **/***********,
+                  ******   **//////////****
+                ***/**///////////////////////**
+              ****///////////**////////////////(**
+             ***////& &////////////% &////* ,////(**
+            *//////&&&/////////////&&&//(/////((((((*
+           **/////////&&&&&&&&&&&&////(//((/(((((((((/*
+           **/////////&&&&&&/****&&//((* /(((((((((((((*
+           ,*////* *///&&&*******&*/(((((((((((((((((((**
+            **////////////*//(**(/(/((((((((((((((((/(((*
+             **//////////////(((/(((((((((/ .*((((((((((**
+               **////////(/((((/((((((((((((((((((((((((/*
+                  **(((///(((((//((((((((((((((((((((((#**
+                      **/((((((((((((((((/*(((((((((((((*
+                           ***((((((((((((((((((#(((((**    */*///
+                                    *****************       *((((    .*/
+`;
+registerCommand({
+  name: "zammy",
+  description: "Say hi to Zammy the slime!",
+  usage: "/zammy [mood|ascii|moods]",
+  async execute(args2) {
+    const mood = args2[0] || "happy";
+    const termWidth = process.stdout.columns || 80;
+    if (mood === "ascii" || mood === "mascot") {
+      console.log("");
+      if (termWidth < MIN_WIDTH_FOR_ASCII) {
+        console.log(`  ${miniSlime.happy} Hi! I'm Zammy!`);
+        console.log(`  ${theme.dim("(widen your terminal to see my full form!)")}`);
+      } else {
+        console.log(theme.primary(asciiMascot));
+      }
+      console.log(`  ${theme.secondary(`"${getGreeting()}"`)}`);
+      console.log("");
+      return;
+    }
+    if (mood === "moods" || mood === "all") {
+      console.log("");
+      console.log(`  ${symbols.sparkle} ${theme.primary("Zammy's moods:")} ${symbols.sparkle}`);
+      console.log("");
+      if (termWidth < MIN_WIDTH_FOR_MASCOT3) {
+        for (const m of validMoods) {
+          const mini = miniSlime[m];
+          if (mini) {
+            console.log(`  ${mini}  ${theme.dim(m)}`);
+          }
+        }
+        console.log("");
+        console.log(`  ${theme.dim("(widen your terminal to see full mood sprites!)")}`);
+      } else {
+        for (const m of validMoods) {
+          const frameFunc2 = slimeFrames[m];
+          if (frameFunc2) {
+            console.log(theme.secondary(`  \u2500\u2500\u2500 ${m.toUpperCase()} \u2500\u2500\u2500`));
+            const art = frameFunc2();
+            art.forEach((line) => console.log("  " + line));
+            console.log("");
+          }
+        }
+      }
+      return;
+    }
+    if (!validMoods.includes(mood)) {
+      console.log("");
+      console.log(`  ${miniSlime.surprised} ${theme.warning("I don't know that mood!")}`);
+      console.log(`  ${theme.dim(`Try: ${validMoods.join(", ")}, ascii`)}`);
+      console.log(`  ${theme.dim(`Or: /zammy moods`)}`);
+      console.log("");
+      return;
+    }
+    const frameFunc = slimeFrames[mood];
+    const greeting = getGreeting();
+    console.log("");
+    if (termWidth < MIN_WIDTH_FOR_MASCOT3) {
+      const mini = miniSlime[mood] || miniSlime.happy;
+      console.log(`  ${mini}`);
+    } else if (frameFunc) {
+      const art = frameFunc();
+      art.forEach((line) => console.log("  " + line));
+    }
+    console.log("");
+    console.log(`  ${theme.secondary(`"${greeting}"`)}`);
+    console.log("");
+    console.log(`  ${theme.dim("I'm Zammy, your CLI buddy! Type /help to see what I can do~")}`);
+    console.log("");
+  }
+});
+
+// src/commands/creative/asciiart.ts
+import Jimp from "jimp";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve2 } from "path";
+var CHAR_RAMPS = {
+  // Standard - 10 levels, balanced
+  standard: " .:-=+*#%@",
+  // Detailed - 16 levels, more gradation
+  detailed: " .'`^\",:;Il!i><~+_-?][}{1)(|/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$",
+  // Block characters - uses Unicode block elements for smoother look
+  blocks: " \u2591\u2592\u2593\u2588",
+  // Simple - 5 levels for cleaner output
   simple: " .:\u2591\u2588",
   // Extended - Maximum depth with 70 characters
   extended: "$@B%8&WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\\|()1{}[]?-_+~<>i!lI;:,\"^`'. "
@@ -1682,8 +2521,8 @@ var SOBEL_Y = [
   [1, 2, 1]
 ];
 function getAsciiChar(brightness, ramp, inverted) {
-  const b = Math.max(0, Math.min(255, brightness));
-  const index = Math.floor(b / 255 * (ramp.length - 1));
+  const b3 = Math.max(0, Math.min(255, brightness));
+  const index = Math.floor(b3 / 255 * (ramp.length - 1));
   return inverted ? ramp[ramp.length - 1 - index] : ramp[index];
 }
 async function applyEdgeEnhancement(image, strength) {
@@ -1763,8 +2602,8 @@ registerCommand({
         i++;
       }
     }
-    const fullPath = resolve(process.cwd(), imagePath);
-    if (!existsSync3(fullPath)) {
+    const fullPath = resolve2(process.cwd(), imagePath);
+    if (!existsSync4(fullPath)) {
       console.log(theme.error(`File not found: ${imagePath}`));
       return;
     }
@@ -2045,7 +2884,7 @@ registerCommand({
 });
 
 // src/commands/creative/color.ts
-import chalk2 from "chalk";
+import chalk4 from "chalk";
 
 // src/handlers/creative/color.ts
 function hexToRgb(hex) {
@@ -2056,14 +2895,14 @@ function hexToRgb(hex) {
     b: parseInt(result[3], 16)
   } : null;
 }
-function rgbToHex(r, g, b) {
-  return "#" + [r, g, b].map((x) => x.toString(16).padStart(2, "0")).join("");
+function rgbToHex(r, g, b3) {
+  return "#" + [r, g, b3].map((x) => x.toString(16).padStart(2, "0")).join("");
 }
-function rgbToHsl(r, g, b) {
+function rgbToHsl(r, g, b3) {
   r /= 255;
   g /= 255;
-  b /= 255;
-  const max = Math.max(r, g, b), min = Math.min(r, g, b);
+  b3 /= 255;
+  const max = Math.max(r, g, b3), min = Math.min(r, g, b3);
   let h = 0, s = 0;
   const l = (max + min) / 2;
   if (max !== min) {
@@ -2071,20 +2910,20 @@ function rgbToHsl(r, g, b) {
     s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
     switch (max) {
       case r:
-        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+        h = ((g - b3) / d + (g < b3 ? 6 : 0)) / 6;
         break;
       case g:
-        h = ((b - r) / d + 2) / 6;
+        h = ((b3 - r) / d + 2) / 6;
         break;
-      case b:
+      case b3:
         h = ((r - g) / d + 4) / 6;
         break;
     }
   }
   return { h: Math.round(h * 360), s: Math.round(s * 100), l: Math.round(l * 100) };
 }
-function getLuminance(r, g, b) {
-  return (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+function getLuminance(r, g, b3) {
+  return (0.299 * r + 0.587 * g + 0.114 * b3) / 255;
 }
 function randomColor() {
   return {
@@ -2094,12 +2933,12 @@ function randomColor() {
   };
 }
 function parseColor(input) {
-  let r, g, b;
+  let r, g, b3;
   if (!input || input === "random") {
     const rgb = randomColor();
     r = rgb.r;
     g = rgb.g;
-    b = rgb.b;
+    b3 = rgb.b;
   } else {
     const hexMatch = input.match(/^#?([a-f\d]{6}|[a-f\d]{3})$/i);
     if (hexMatch) {
@@ -2111,7 +2950,7 @@ function parseColor(input) {
       if (rgb) {
         r = rgb.r;
         g = rgb.g;
-        b = rgb.b;
+        b3 = rgb.b;
       } else {
         return { error: "Invalid hex color" };
       }
@@ -2120,24 +2959,24 @@ function parseColor(input) {
       if (rgbMatch) {
         r = Math.min(255, parseInt(rgbMatch[1]));
         g = Math.min(255, parseInt(rgbMatch[2]));
-        b = Math.min(255, parseInt(rgbMatch[3]));
+        b3 = Math.min(255, parseInt(rgbMatch[3]));
       } else {
         const nums = input.split(/[\s,]+/).map((n) => parseInt(n)).filter((n) => !isNaN(n));
         if (nums.length === 3) {
           r = Math.min(255, nums[0]);
           g = Math.min(255, nums[1]);
-          b = Math.min(255, nums[2]);
+          b3 = Math.min(255, nums[2]);
         } else {
           return { error: "Could not parse color" };
         }
       }
     }
   }
-  const hex = rgbToHex(r, g, b);
-  const hsl = rgbToHsl(r, g, b);
-  const luminance = getLuminance(r, g, b);
+  const hex = rgbToHex(r, g, b3);
+  const hsl = rgbToHsl(r, g, b3);
+  const luminance = getLuminance(r, g, b3);
   return {
-    rgb: { r, g, b },
+    rgb: { r, g, b: b3 },
     hex,
     hsl,
     luminance,
@@ -2194,7 +3033,7 @@ registerCommand({
     console.log("");
     console.log(`  ${symbols.palette} ${theme.gradient("COLOR CONVERTER")} ${symbols.palette}`);
     console.log("");
-    const colorBlock = chalk2.bgHex(hex).hex(textColor);
+    const colorBlock = chalk4.bgHex(hex).hex(textColor);
     console.log(`  ${colorBlock("                                        ")}`);
     console.log(`  ${colorBlock("                                        ")}`);
     console.log(`  ${colorBlock(`      ${hex.toUpperCase()}                            `.slice(0, 40))}`);
@@ -2209,14 +3048,14 @@ registerCommand({
     let shadesLine = "  ";
     const shades = generateShades(rgb);
     for (const shade of shades) {
-      shadesLine += chalk2.bgRgb(shade.r, shade.g, shade.b)("  ");
+      shadesLine += chalk4.bgRgb(shade.r, shade.g, shade.b)("  ");
     }
     console.log(shadesLine);
     console.log(`  ${theme.dim("Tints:")}`);
     let tintsLine = "  ";
     const tints = generateTints(rgb);
     for (const tint of tints) {
-      tintsLine += chalk2.bgRgb(tint.r, tint.g, tint.b)("  ");
+      tintsLine += chalk4.bgRgb(tint.r, tint.g, tint.b)("  ");
     }
     console.log(tintsLine);
     console.log("");
@@ -2280,189 +3119,2016 @@ registerCommand({
     ], 70));
     console.log("");
   }
-});
+});
+
+// src/handlers/dev/uuid.ts
+import { randomUUID } from "crypto";
+function generateUuids(count = 1) {
+  const safeCount = Math.min(Math.max(1, count), 10);
+  const uuids = [];
+  for (let i = 0; i < safeCount; i++) {
+    uuids.push(randomUUID());
+  }
+  return {
+    uuids,
+    count: safeCount
+  };
+}
+
+// src/commands/dev/uuid.ts
+registerCommand({
+  name: "uuid",
+  description: "Generate UUID(s)",
+  usage: "/uuid [count]",
+  async execute(args2) {
+    const count = parseInt(args2[0]) || 1;
+    const result = generateUuids(count);
+    console.log("");
+    console.log(`  ${symbols.sparkle} ${theme.gradient("UUID GENERATOR")} ${symbols.sparkle}`);
+    console.log("");
+    result.uuids.forEach((uuid, i) => {
+      console.log(`  ${theme.dim(`${i + 1}.`)} ${theme.primary(uuid)}`);
+    });
+    console.log("");
+    if (result.count === 1) {
+      console.log(theme.dim("  Tip: /uuid 5 generates 5 UUIDs"));
+    }
+    console.log("");
+  }
+});
+
+// src/handlers/dev/encode.ts
+var SUPPORTED_METHODS = ["base64", "url", "hex"];
+function isValidMethod(method) {
+  return SUPPORTED_METHODS.includes(method.toLowerCase());
+}
+function encodeText(text, method, direction) {
+  let output;
+  if (direction === "encode") {
+    switch (method) {
+      case "base64":
+        output = Buffer.from(text).toString("base64");
+        break;
+      case "url":
+        output = encodeURIComponent(text);
+        break;
+      case "hex":
+        output = Buffer.from(text).toString("hex");
+        break;
+    }
+  } else {
+    switch (method) {
+      case "base64":
+        output = Buffer.from(text, "base64").toString("utf-8");
+        break;
+      case "url":
+        output = decodeURIComponent(text);
+        break;
+      case "hex":
+        output = Buffer.from(text, "hex").toString("utf-8");
+        break;
+    }
+  }
+  return {
+    method: method.toUpperCase(),
+    direction,
+    input: text,
+    output
+  };
+}
+
+// src/commands/dev/encode.ts
+registerCommand({
+  name: "encode",
+  description: "Encode/decode text (base64, url, hex)",
+  usage: "/encode <method> <encode|decode> <text>",
+  async execute(args2) {
+    if (args2.length < 2) {
+      console.log("");
+      console.log(theme.error("Usage: /encode <method> <encode|decode> <text>"));
+      console.log(theme.dim(`  Methods: ${SUPPORTED_METHODS.join(", ")}`));
+      console.log(theme.dim("  Example: /encode base64 encode hello"));
+      console.log(theme.dim("  Example: /encode url decode hello%20world"));
+      console.log("");
+      return;
+    }
+    const method = args2[0].toLowerCase();
+    const action = args2[1].toLowerCase();
+    const text = args2.slice(2).join(" ");
+    if (!isValidMethod(method)) {
+      console.log(theme.error(`Unknown method: ${method}. Use ${SUPPORTED_METHODS.join(", ")}`));
+      return;
+    }
+    if (action !== "encode" && action !== "decode") {
+      console.log(theme.error(`Unknown action: ${action}. Use encode or decode`));
+      return;
+    }
+    if (!text) {
+      console.log(theme.error("Please provide text to encode/decode"));
+      return;
+    }
+    try {
+      const result = encodeText(text, method, action);
+      console.log("");
+      console.log(box.draw([
+        "",
+        `  ${symbols.sparkle} ${theme.gradient(result.method + " " + result.direction.toUpperCase())}`,
+        "",
+        `  ${theme.dim("Input:")}`,
+        `  ${theme.secondary(result.input.length > 50 ? result.input.slice(0, 50) + "..." : result.input)}`,
+        "",
+        `  ${theme.dim("Output:")}`,
+        `  ${theme.success(result.output.length > 50 ? result.output.slice(0, 50) + "..." : result.output)}`,
+        "",
+        ...result.output.length > 50 ? [`  ${theme.dim("(Full output: " + result.output.length + " chars)")}`] : [],
+        ""
+      ], 60));
+      console.log("");
+      if (result.output.length > 50) {
+        console.log(theme.dim("  Full result:"));
+        console.log(`  ${result.output}`);
+        console.log("");
+      }
+    } catch (e) {
+      console.log(theme.error(`Failed to ${action}: Invalid input for ${method}`));
+    }
+  }
+});
+
+// src/handlers/dev/json.ts
+function validateJson(input) {
+  try {
+    const data = JSON.parse(input);
+    return { valid: true, data };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid JSON";
+    return { valid: false, error: message };
+  }
+}
+function formatJson(input, indent = 2) {
+  try {
+    const data = JSON.parse(input);
+    const formatted = JSON.stringify(data, null, indent);
+    return { valid: true, data, formatted };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid JSON";
+    return { valid: false, error: message };
+  }
+}
+function minifyJson(input) {
+  try {
+    const data = JSON.parse(input);
+    const formatted = JSON.stringify(data);
+    return { valid: true, data, formatted };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid JSON";
+    return { valid: false, error: message };
+  }
+}
+function queryJson(input, path) {
+  try {
+    const data = JSON.parse(input);
+    const parts = path.replace(/^\$\.?/, "").split(".").filter(Boolean);
+    let current = data;
+    for (const part of parts) {
+      const arrayMatch = part.match(/^(\w*)\[(\d+)\]$/);
+      if (arrayMatch) {
+        const [, key, index] = arrayMatch;
+        if (key) {
+          current = current[key];
+        }
+        if (Array.isArray(current)) {
+          current = current[parseInt(index)];
+        } else {
+          return { valid: false, error: `Not an array at ${part}` };
+        }
+      } else {
+        if (current && typeof current === "object") {
+          current = current[part];
+        } else {
+          return { valid: false, error: `Cannot access ${part}` };
+        }
+      }
+    }
+    return { valid: true, data: current, formatted: JSON.stringify(current, null, 2) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid JSON";
+    return { valid: false, error: message };
+  }
+}
+function getJsonStats(input) {
+  try {
+    let countKeys2 = function(obj, depth = 0) {
+      if (typeof obj !== "object" || obj === null) {
+        return { keys: 0, maxDepth: depth };
+      }
+      let keys = 0;
+      let maxDepth = depth;
+      if (Array.isArray(obj)) {
+        for (const item of obj) {
+          const result = countKeys2(item, depth + 1);
+          keys += result.keys;
+          maxDepth = Math.max(maxDepth, result.maxDepth);
+        }
+      } else {
+        keys = Object.keys(obj).length;
+        for (const value of Object.values(obj)) {
+          const result = countKeys2(value, depth + 1);
+          keys += result.keys;
+          maxDepth = Math.max(maxDepth, result.maxDepth);
+        }
+      }
+      return { keys, maxDepth };
+    };
+    var countKeys = countKeys2;
+    const data = JSON.parse(input);
+    const stats = countKeys2(data);
+    const size = new Blob([input]).size;
+    const sizeStr = size < 1024 ? `${size}B` : size < 1024 * 1024 ? `${(size / 1024).toFixed(1)}KB` : `${(size / 1024 / 1024).toFixed(1)}MB`;
+    return { keys: stats.keys, depth: stats.maxDepth, size: sizeStr };
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/dev/json.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+registerCommand({
+  name: "json",
+  description: "JSON tools (validate, format, query)",
+  usage: "/json <action> <input>\n\n  Actions: validate, format, minify, query, stats",
+  async execute(args2) {
+    const action = args2[0]?.toLowerCase();
+    const input = args2.slice(1).join(" ");
+    if (!action) {
+      console.log("");
+      console.log(`  ${symbols.sparkle} ${theme.gradient("JSON TOOLS")}`);
+      console.log("");
+      console.log(`  ${theme.dim("Usage:")} /json <action> <input>`);
+      console.log("");
+      console.log(`  ${theme.dim("Actions:")}`);
+      console.log(`    ${theme.primary("validate")} <json|@file>  ${theme.dim("Check if JSON is valid")}`);
+      console.log(`    ${theme.primary("format")} <json|@file>    ${theme.dim("Pretty-print JSON")}`);
+      console.log(`    ${theme.primary("minify")} <json|@file>    ${theme.dim("Minify JSON")}`);
+      console.log(`    ${theme.primary("query")} <path> <json>    ${theme.dim("Query with path (e.g., users[0].name)")}`);
+      console.log(`    ${theme.primary("stats")} <json|@file>     ${theme.dim("Show JSON statistics")}`);
+      console.log("");
+      console.log(`  ${theme.dim("Use @filename to read from file")}`);
+      console.log("");
+      return;
+    }
+    let jsonContent = input;
+    if (input.startsWith("@")) {
+      const filePath = input.slice(1);
+      if (!existsSync5(filePath)) {
+        console.log("");
+        console.log(`  ${symbols.cross} ${theme.error(`File not found: ${filePath}`)}`);
+        console.log("");
+        return;
+      }
+      jsonContent = readFileSync3(filePath, "utf-8");
+    }
+    console.log("");
+    switch (action) {
+      case "validate": {
+        if (!jsonContent) {
+          console.log(`  ${symbols.warning} ${theme.warning("Usage:")} /json validate <json|@file>`);
+          break;
+        }
+        const result = validateJson(jsonContent);
+        if (result.valid) {
+          console.log(`  ${symbols.check} ${theme.success("Valid JSON")}`);
+        } else {
+          console.log(`  ${symbols.cross} ${theme.error("Invalid JSON")}`);
+          console.log(`  ${theme.dim(result.error || "")}`);
+        }
+        break;
+      }
+      case "format":
+      case "pretty": {
+        if (!jsonContent) {
+          console.log(`  ${symbols.warning} ${theme.warning("Usage:")} /json format <json|@file>`);
+          break;
+        }
+        const result = formatJson(jsonContent);
+        if (result.valid && result.formatted) {
+          console.log(`  ${symbols.check} ${theme.success("Formatted JSON:")}`);
+          console.log("");
+          for (const line of result.formatted.split("\n")) {
+            console.log(`  ${theme.primary(line)}`);
+          }
+        } else {
+          console.log(`  ${symbols.cross} ${theme.error("Invalid JSON")}`);
+          console.log(`  ${theme.dim(result.error || "")}`);
+        }
+        break;
+      }
+      case "minify":
+      case "min": {
+        if (!jsonContent) {
+          console.log(`  ${symbols.warning} ${theme.warning("Usage:")} /json minify <json|@file>`);
+          break;
+        }
+        const result = minifyJson(jsonContent);
+        if (result.valid && result.formatted) {
+          console.log(`  ${symbols.check} ${theme.success("Minified:")}`);
+          console.log("");
+          console.log(`  ${theme.primary(result.formatted)}`);
+        } else {
+          console.log(`  ${symbols.cross} ${theme.error("Invalid JSON")}`);
+          console.log(`  ${theme.dim(result.error || "")}`);
+        }
+        break;
+      }
+      case "query":
+      case "get": {
+        const path = args2[1];
+        const queryInput = args2.slice(2).join(" ");
+        if (!path || !queryInput) {
+          console.log(`  ${symbols.warning} ${theme.warning("Usage:")} /json query <path> <json|@file>`);
+          console.log("");
+          console.log(`  ${theme.dim("Examples:")}`);
+          console.log(`    /json query name '{"name": "John"}'`);
+          console.log(`    /json query users[0].email @data.json`);
+          break;
+        }
+        let queryJsonContent = queryInput;
+        if (queryInput.startsWith("@")) {
+          const filePath = queryInput.slice(1);
+          if (!existsSync5(filePath)) {
+            console.log(`  ${symbols.cross} ${theme.error(`File not found: ${filePath}`)}`);
+            break;
+          }
+          queryJsonContent = readFileSync3(filePath, "utf-8");
+        }
+        const result = queryJson(queryJsonContent, path);
+        if (result.valid) {
+          console.log(`  ${symbols.check} ${theme.success(`Result for "${path}":`)} `);
+          console.log("");
+          if (result.formatted) {
+            for (const line of result.formatted.split("\n")) {
+              console.log(`  ${theme.primary(line)}`);
+            }
+          } else {
+            console.log(`  ${theme.dim("undefined")}`);
+          }
+        } else {
+          console.log(`  ${symbols.cross} ${theme.error(result.error || "Query failed")}`);
+        }
+        break;
+      }
+      case "stats":
+      case "info": {
+        if (!jsonContent) {
+          console.log(`  ${symbols.warning} ${theme.warning("Usage:")} /json stats <json|@file>`);
+          break;
+        }
+        const stats = getJsonStats(jsonContent);
+        if (stats) {
+          console.log(`  ${symbols.sparkle} ${theme.gradient("JSON STATS")}`);
+          console.log("");
+          console.log(`  ${theme.dim("Total keys:")}  ${theme.primary(stats.keys.toString())}`);
+          console.log(`  ${theme.dim("Max depth:")}   ${theme.primary(stats.depth.toString())}`);
+          console.log(`  ${theme.dim("Size:")}        ${theme.primary(stats.size)}`);
+        } else {
+          console.log(`  ${symbols.cross} ${theme.error("Invalid JSON")}`);
+        }
+        break;
+      }
+      default:
+        console.log(`  ${symbols.cross} ${theme.error(`Unknown action: ${action}`)}`);
+        console.log(`  ${theme.dim("Run /json to see available actions")}`);
+    }
+    console.log("");
+  }
+});
+
+// src/handlers/dev/request.ts
+import https from "https";
+import http from "http";
+import { URL } from "url";
+async function makeRequest(urlStr, options = { method: "GET" }) {
+  const startTime2 = Date.now();
+  return new Promise((resolve6) => {
+    const timeout = setTimeout(() => {
+      resolve6({ success: false, error: "Request timed out" });
+    }, options.timeout || 3e4);
+    try {
+      const url = new URL(urlStr.startsWith("http") ? urlStr : `https://${urlStr}`);
+      const client = url.protocol === "https:" ? https : http;
+      const reqOptions = {
+        hostname: url.hostname,
+        port: url.port || (url.protocol === "https:" ? 443 : 80),
+        path: url.pathname + url.search,
+        method: options.method.toUpperCase(),
+        headers: {
+          "User-Agent": "Zammy-CLI/1.0",
+          ...options.headers
+        }
+      };
+      const req = client.request(reqOptions, (res) => {
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        res.on("end", () => {
+          clearTimeout(timeout);
+          resolve6({
+            success: true,
+            statusCode: res.statusCode,
+            statusMessage: res.statusMessage,
+            headers: res.headers,
+            body,
+            time: Date.now() - startTime2
+          });
+        });
+      });
+      req.on("error", (error) => {
+        clearTimeout(timeout);
+        resolve6({ success: false, error: error.message });
+      });
+      if (options.body) {
+        req.write(options.body);
+      }
+      req.end();
+    } catch (error) {
+      clearTimeout(timeout);
+      resolve6({ success: false, error: error instanceof Error ? error.message : "Request failed" });
+    }
+  });
+}
+function tryParseJson(body) {
+  try {
+    const parsed = JSON.parse(body);
+    return { isJson: true, formatted: JSON.stringify(parsed, null, 2) };
+  } catch {
+    return { isJson: false };
+  }
+}
+
+// src/commands/dev/request.ts
+registerCommand({
+  name: "request",
+  description: "Make HTTP requests",
+  usage: "/request <method> <url> [options]",
+  async execute(args2) {
+    if (args2.length < 1) {
+      console.log("");
+      console.log(`  ${symbols.sparkle} ${theme.gradient("HTTP REQUEST")}`);
+      console.log("");
+      console.log(`  ${theme.dim("Usage:")} /request <method> <url> [options]`);
+      console.log("");
+      console.log(`  ${theme.dim("Methods:")} GET, POST, PUT, DELETE, PATCH, HEAD`);
+      console.log("");
+      console.log(`  ${theme.dim("Examples:")}`);
+      console.log(`    /request GET https://api.github.com`);
+      console.log(`    /request POST https://httpbin.org/post --body '{"name":"test"}'`);
+      console.log(`    /request GET api.example.com/users`);
+      console.log("");
+      return;
+    }
+    let method = "GET";
+    let url = args2[0];
+    const methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+    if (methods.includes(args2[0].toUpperCase())) {
+      method = args2[0].toUpperCase();
+      url = args2[1];
+    }
+    if (!url) {
+      console.log("");
+      console.log(`  ${symbols.cross} ${theme.error("URL is required")}`);
+      console.log("");
+      return;
+    }
+    const headers = {};
+    let body;
+    for (let i = 2; i < args2.length; i++) {
+      if (args2[i] === "--header" || args2[i] === "-H") {
+        const header = args2[++i];
+        if (header) {
+          const [key, ...valueParts] = header.split(":");
+          headers[key.trim()] = valueParts.join(":").trim();
+        }
+      } else if (args2[i] === "--body" || args2[i] === "-d") {
+        body = args2[++i];
+      }
+    }
+    console.log("");
+    console.log(`  ${theme.dim(`${method} ${url}...`)}`);
+    const result = await makeRequest(url, { method, headers, body });
+    process.stdout.write("\x1B[1A\x1B[2K");
+    if (!result.success) {
+      console.log(`  ${symbols.cross} ${theme.error(result.error || "Request failed")}`);
+      console.log("");
+      return;
+    }
+    const statusColor = result.statusCode && result.statusCode >= 200 && result.statusCode < 300 ? theme.success : result.statusCode && result.statusCode >= 400 ? theme.error : theme.warning;
+    console.log(`  ${statusColor(`${result.statusCode} ${result.statusMessage}`)} ${theme.dim(`(${result.time}ms)`)}`);
+    console.log("");
+    if (result.headers) {
+      const importantHeaders = ["content-type", "content-length", "server", "date"];
+      console.log(`  ${theme.dim("Headers:")}`);
+      for (const key of importantHeaders) {
+        if (result.headers[key]) {
+          console.log(`    ${theme.secondary(key)}: ${result.headers[key]}`);
+        }
+      }
+      console.log("");
+    }
+    if (result.body && method !== "HEAD") {
+      console.log(`  ${theme.dim("Body:")}`);
+      const jsonResult = tryParseJson(result.body);
+      if (jsonResult.isJson && jsonResult.formatted) {
+        const lines = jsonResult.formatted.split("\n");
+        const displayLines = lines.slice(0, 30);
+        for (const line of displayLines) {
+          console.log(`  ${theme.primary(line)}`);
+        }
+        if (lines.length > 30) {
+          console.log(`  ${theme.dim(`... and ${lines.length - 30} more lines`)}`);
+        }
+      } else {
+        const lines = result.body.split("\n").slice(0, 20);
+        for (const line of lines) {
+          console.log(`  ${line.slice(0, 100)}`);
+        }
+        if (result.body.split("\n").length > 20) {
+          console.log(`  ${theme.dim("... (truncated)")}`);
+        }
+      }
+    }
+    console.log("");
+  }
+});
+
+// src/handlers/dev/diff.ts
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
+function diffFiles(file1, file2) {
+  if (!existsSync6(file1)) {
+    return { success: false, lines: [], stats: { additions: 0, deletions: 0, unchanged: 0 }, error: `File not found: ${file1}` };
+  }
+  if (!existsSync6(file2)) {
+    return { success: false, lines: [], stats: { additions: 0, deletions: 0, unchanged: 0 }, error: `File not found: ${file2}` };
+  }
+  try {
+    const content1 = readFileSync4(file1, "utf-8");
+    const content2 = readFileSync4(file2, "utf-8");
+    return diffStrings(content1, content2);
+  } catch (error) {
+    return {
+      success: false,
+      lines: [],
+      stats: { additions: 0, deletions: 0, unchanged: 0 },
+      error: error instanceof Error ? error.message : "Failed to read files"
+    };
+  }
+}
+function diffStrings(str1, str2) {
+  const lines1 = str1.split("\n");
+  const lines2 = str2.split("\n");
+  const lcs = computeLCS(lines1, lines2);
+  const diff = buildDiff(lines1, lines2, lcs);
+  let additions = 0;
+  let deletions = 0;
+  let unchanged = 0;
+  for (const line of diff) {
+    if (line.type === "add") additions++;
+    else if (line.type === "remove") deletions++;
+    else if (line.type === "same") unchanged++;
+  }
+  return {
+    success: true,
+    lines: diff,
+    stats: { additions, deletions, unchanged }
+  };
+}
+function computeLCS(lines1, lines2) {
+  const m = lines1.length;
+  const n = lines2.length;
+  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (lines1[i - 1] === lines2[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+  return dp;
+}
+function buildDiff(lines1, lines2, lcs) {
+  const result = [];
+  let i = lines1.length;
+  let j = lines2.length;
+  const temp = [];
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && lines1[i - 1] === lines2[j - 1]) {
+      temp.push({ type: "same", content: lines1[i - 1], lineNum1: i, lineNum2: j });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || lcs[i][j - 1] >= lcs[i - 1][j])) {
+      temp.push({ type: "add", content: lines2[j - 1], lineNum2: j });
+      j--;
+    } else if (i > 0) {
+      temp.push({ type: "remove", content: lines1[i - 1], lineNum1: i });
+      i--;
+    }
+  }
+  return temp.reverse();
+}
+function formatDiffStats(stats) {
+  const parts = [];
+  if (stats.additions > 0) parts.push(`+${stats.additions}`);
+  if (stats.deletions > 0) parts.push(`-${stats.deletions}`);
+  if (stats.unchanged > 0) parts.push(`=${stats.unchanged}`);
+  return parts.join(", ");
+}
+
+// src/commands/dev/diff.ts
+import { basename as basename2 } from "path";
+registerCommand({
+  name: "diff",
+  description: "Compare two files",
+  usage: "/diff <file1> <file2>",
+  async execute(args2) {
+    if (args2.length < 2) {
+      console.log("");
+      console.log(`  ${symbols.sparkle} ${theme.gradient("FILE DIFF")}`);
+      console.log("");
+      console.log(`  ${theme.dim("Usage:")} /diff <file1> <file2>`);
+      console.log("");
+      console.log(`  ${theme.dim("Example:")}`);
+      console.log(`    /diff old.json new.json`);
+      console.log(`    /diff config.ts config.backup.ts`);
+      console.log("");
+      return;
+    }
+    const file1 = args2[0];
+    const file2 = args2[1];
+    console.log("");
+    const result = diffFiles(file1, file2);
+    if (!result.success) {
+      console.log(`  ${symbols.cross} ${theme.error(result.error || "Diff failed")}`);
+      console.log("");
+      return;
+    }
+    console.log(`  ${symbols.sparkle} ${theme.gradient("DIFF")}: ${theme.primary(basename2(file1))} ${theme.dim("\u2192")} ${theme.primary(basename2(file2))}`);
+    console.log(`  ${theme.dim(formatDiffStats(result.stats))}`);
+    console.log("");
+    if (result.stats.additions === 0 && result.stats.deletions === 0) {
+      console.log(`  ${symbols.check} ${theme.success("Files are identical")}`);
+      console.log("");
+      return;
+    }
+    let contextLines = 3;
+    let lastShownIndex = -contextLines - 1;
+    const linesToShow = [];
+    result.lines.forEach((line, i) => {
+      if (line.type !== "same") {
+        for (let j = Math.max(0, i - contextLines); j <= Math.min(result.lines.length - 1, i + contextLines); j++) {
+          if (!linesToShow.includes(j)) {
+            linesToShow.push(j);
+          }
+        }
+      }
+    });
+    linesToShow.sort((a, b3) => a - b3);
+    for (let i = 0; i < linesToShow.length; i++) {
+      const lineIndex = linesToShow[i];
+      const line = result.lines[lineIndex];
+      if (i > 0 && linesToShow[i] - linesToShow[i - 1] > 1) {
+        console.log(`  ${theme.dim("...")}`);
+      }
+      const lineNum = line.lineNum1 || line.lineNum2 || "";
+      const numStr = lineNum.toString().padStart(4);
+      if (line.type === "add") {
+        console.log(`  ${theme.success("+")} ${theme.dim(numStr)} ${theme.success(line.content)}`);
+      } else if (line.type === "remove") {
+        console.log(`  ${theme.error("-")} ${theme.dim(numStr)} ${theme.error(line.content)}`);
+      } else {
+        console.log(`  ${theme.dim(" ")} ${theme.dim(numStr)} ${line.content}`);
+      }
+    }
+    console.log("");
+  }
+});
+
+// src/commands/info/weather.ts
+registerCommand({
+  name: "weather",
+  description: "Get current weather for a city",
+  usage: "/weather <city>",
+  async execute(args2) {
+    const city = args2.join(" ") || "London";
+    console.log(theme.dim(`Fetching weather for ${city}...`));
+    try {
+      const response = await fetch(`https://wttr.in/${encodeURIComponent(city)}?format=j1`);
+      if (!response.ok) {
+        console.log(theme.error(`Could not fetch weather for "${city}"`));
+        return;
+      }
+      const data = await response.json();
+      const current = data.current_condition[0];
+      const location = data.nearest_area[0];
+      const temp = current.temp_C;
+      const feelsLike = current.FeelsLikeC;
+      const desc = current.weatherDesc[0].value;
+      const humidity = current.humidity;
+      const wind = current.windspeedKmph;
+      const cityName = location.areaName[0].value;
+      const country = location.country[0].value;
+      console.log("");
+      console.log(theme.highlight(`${cityName}, ${country}`));
+      console.log("");
+      console.log(`  ${theme.primary(desc)}`);
+      console.log(`  Temperature: ${theme.warning(temp + "\xB0C")} (feels like ${feelsLike}\xB0C)`);
+      console.log(`  Humidity: ${humidity}%`);
+      console.log(`  Wind: ${wind} km/h`);
+      console.log("");
+    } catch (error) {
+      console.log(theme.error(`Error fetching weather: ${error}`));
+    }
+  }
+});
+
+// src/plugins/loader.ts
+import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync7, mkdirSync as mkdirSync2 } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
+import { homedir as homedir3 } from "os";
+import { pathToFileURL, fileURLToPath as fileURLToPath2 } from "url";
+
+// src/plugins/api.ts
+import { execSync, spawn as nodeSpawn } from "child_process";
+import { join as join5 } from "path";
+
+// src/plugins/storage.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync } from "fs";
+import { join as join4 } from "path";
+function createPluginStorage(pluginName, dataDir) {
+  const storagePath = join4(dataDir, "data.json");
+  if (!existsSync7(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+  function loadData() {
+    try {
+      if (existsSync7(storagePath)) {
+        const content = readFileSync5(storagePath, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {
+    }
+    return {};
+  }
+  function saveData(data) {
+    try {
+      writeFileSync3(storagePath, JSON.stringify(data, null, 2), "utf-8");
+    } catch (error) {
+      console.error(`Failed to save plugin storage for ${pluginName}:`, error);
+    }
+  }
+  return {
+    get(key) {
+      const data = loadData();
+      return data[key];
+    },
+    set(key, value) {
+      const data = loadData();
+      data[key] = value;
+      saveData(data);
+    },
+    delete(key) {
+      const data = loadData();
+      delete data[key];
+      saveData(data);
+    },
+    clear() {
+      saveData({});
+    },
+    getAll() {
+      return loadData();
+    }
+  };
+}
+
+// src/plugins/api.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname2 } from "path";
+function getZammyVersion() {
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname2(__filename);
+    const pkgPath = join5(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function createPluginUI() {
+  return {
+    theme: {
+      primary: theme.primary,
+      secondary: theme.secondary,
+      accent: theme.accent,
+      success: theme.success,
+      warning: theme.warning,
+      error: theme.error,
+      info: theme.info,
+      dim: theme.dim,
+      gradient: theme.gradient
+    },
+    symbols: {
+      check: symbols.check,
+      cross: symbols.cross,
+      star: symbols.star,
+      arrow: symbols.arrow,
+      bullet: symbols.bullet,
+      folder: symbols.folder,
+      file: "\u{1F4C4}",
+      // 📄
+      warning: symbols.warning,
+      info: symbols.info,
+      rocket: symbols.rocket,
+      sparkles: symbols.sparkle
+    },
+    box: (content, options) => {
+      const lines = content.split("\n");
+      const width = Math.max(...lines.map((l) => l.replace(/\x1B\[[0-9;]*m/g, "").length)) + 4;
+      return box.draw(lines, width);
+    },
+    progressBar: (current, total, width) => {
+      const percent = Math.round(current / total * 100);
+      return progressBar(percent, width || 30);
+    }
+  };
+}
+function createPluginLogger(pluginName) {
+  const prefix = theme.dim(`[${pluginName}]`);
+  return {
+    info: (message) => console.log(`${prefix} ${theme.info(message)}`),
+    warn: (message) => console.log(`${prefix} ${theme.warning(message)}`),
+    error: (message) => console.log(`${prefix} ${theme.error(message)}`),
+    debug: (message) => {
+      if (process.env.ZAMMY_DEBUG) {
+        console.log(`${prefix} ${theme.dim(message)}`);
+      }
+    }
+  };
+}
+function createPluginShell(manifest) {
+  if (!manifest.permissions?.shell) {
+    return void 0;
+  }
+  return {
+    exec: (command, options) => {
+      try {
+        return execSync(command, {
+          encoding: "utf-8",
+          timeout: options?.timeout || 3e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch (error) {
+        if (error && typeof error === "object" && "stdout" in error) {
+          return error.stdout || "";
+        }
+        throw error;
+      }
+    },
+    spawn: (command, args2) => {
+      return new Promise((resolve6) => {
+        const proc = nodeSpawn(command, args2 || [], {
+          shell: true,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout?.on("data", (data) => {
+          stdout += data.toString();
+        });
+        proc.stderr?.on("data", (data) => {
+          stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+          resolve6({ stdout, stderr, code: code || 0 });
+        });
+        proc.on("error", () => {
+          resolve6({ stdout, stderr, code: 1 });
+        });
+      });
+    }
+  };
+}
+function createPluginAPI(manifest, pluginPath) {
+  const dataDir = pluginPath;
+  const context = {
+    pluginName: manifest.name,
+    pluginVersion: manifest.version,
+    zammyVersion: getZammyVersion(),
+    dataDir,
+    cwd: process.cwd()
+  };
+  return {
+    registerCommand: (command) => {
+      registerPluginCommand(command, manifest.name);
+    },
+    registerCommands: (commands2) => {
+      for (const command of commands2) {
+        registerPluginCommand(command, manifest.name);
+      }
+    },
+    ui: createPluginUI(),
+    storage: createPluginStorage(manifest.name, dataDir),
+    log: createPluginLogger(manifest.name),
+    context,
+    shell: createPluginShell(manifest)
+  };
+}
+
+// src/plugins/loader.ts
+var PLUGINS_DIR = join6(homedir3(), ".zammy", "plugins");
+function getZammyVersion2() {
+  try {
+    const __filename = fileURLToPath2(import.meta.url);
+    const __dirname = dirname3(__filename);
+    const possiblePaths = [
+      join6(__dirname, "package.json"),
+      // Same dir (bundled: dist/)
+      join6(__dirname, "..", "package.json"),
+      // One up (bundled: project root)
+      join6(__dirname, "..", "..", "package.json")
+      // Two up (source: src/plugins/)
+    ];
+    for (const pkgPath of possiblePaths) {
+      if (existsSync8(pkgPath)) {
+        const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+        if (pkg.name === "zammy" && pkg.version) {
+          return pkg.version;
+        }
+      }
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function compareVersions(a, b3) {
+  const partsA = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const partsB = b3.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+  return 0;
+}
+function checkVersionCompatibility(manifest, zammyVersion) {
+  const minVersion = manifest.zammy?.minVersion;
+  const maxVersion = manifest.zammy?.maxVersion;
+  if (minVersion && compareVersions(zammyVersion, minVersion) < 0) {
+    return {
+      compatible: false,
+      reason: `Requires Zammy v${minVersion}+, but you have v${zammyVersion}`
+    };
+  }
+  if (maxVersion && compareVersions(zammyVersion, maxVersion) > 0) {
+    return {
+      compatible: false,
+      reason: `Incompatible with Zammy v${zammyVersion} (max: v${maxVersion})`
+    };
+  }
+  return { compatible: true };
+}
+var discoveredPlugins = /* @__PURE__ */ new Map();
+var loadedPlugins = /* @__PURE__ */ new Map();
+function ensurePluginsDir() {
+  if (!existsSync8(PLUGINS_DIR)) {
+    mkdirSync2(PLUGINS_DIR, { recursive: true });
+  }
+}
+function getPluginsDir() {
+  return PLUGINS_DIR;
+}
+async function discoverPlugins() {
+  ensurePluginsDir();
+  discoveredPlugins.clear();
+  if (!existsSync8(PLUGINS_DIR)) {
+    return [];
+  }
+  const zammyVersion = getZammyVersion2();
+  const entries = readdirSync2(PLUGINS_DIR, { withFileTypes: true });
+  const manifests = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const pluginPath = join6(PLUGINS_DIR, entry.name);
+    const manifestPath = join6(pluginPath, "zammy-plugin.json");
+    if (!existsSync8(manifestPath)) continue;
+    try {
+      const manifestContent = readFileSync7(manifestPath, "utf-8");
+      const manifest = JSON.parse(manifestContent);
+      if (!manifest.name || !manifest.version || !manifest.main || !manifest.commands) {
+        console.log(theme.warning(`  ${symbols.warning} Invalid manifest for plugin in ${entry.name}`));
+        continue;
+      }
+      const compatibility = checkVersionCompatibility(manifest, zammyVersion);
+      if (!compatibility.compatible) {
+        console.log(theme.warning(`  ${symbols.warning} Plugin '${manifest.name}' skipped: ${compatibility.reason}`));
+        continue;
+      }
+      discoveredPlugins.set(manifest.name, { manifest, path: pluginPath });
+      manifests.push(manifest);
+    } catch (error) {
+      console.log(theme.warning(`  ${symbols.warning} Failed to read manifest for ${entry.name}`));
+    }
+  }
+  return manifests;
+}
+async function loadPlugin(name) {
+  if (loadedPlugins.has(name)) {
+    const existing = loadedPlugins.get(name);
+    if (existing.state === "error") {
+      return null;
+    }
+    return existing;
+  }
+  const discovered = discoveredPlugins.get(name);
+  if (!discovered) {
+    return null;
+  }
+  const { manifest, path: pluginPath } = discovered;
+  try {
+    const mainPath = join6(pluginPath, manifest.main);
+    if (!existsSync8(mainPath)) {
+      throw new Error(`Plugin entry point not found: ${mainPath}`);
+    }
+    const moduleUrl = pathToFileURL(mainPath).href;
+    const module = await import(moduleUrl);
+    const plugin = module.default;
+    if (!plugin || typeof plugin.activate !== "function") {
+      throw new Error("Plugin must export a default object with an activate function");
+    }
+    const api = createPluginAPI(manifest, pluginPath);
+    try {
+      await plugin.activate(api);
+    } catch (activationError) {
+      const msg = activationError instanceof Error ? activationError.message : String(activationError);
+      throw new Error(`Plugin activation failed: ${msg}`);
+    }
+    const loaded = {
+      manifest,
+      instance: plugin,
+      path: pluginPath,
+      state: "active"
+    };
+    loadedPlugins.set(name, loaded);
+    return loaded;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(theme.error(`  ${symbols.cross} Failed to load plugin '${name}': ${errorMessage}`));
+    const failedPlugin = {
+      manifest,
+      instance: { activate: async () => {
+      } },
+      path: pluginPath,
+      state: "error"
+    };
+    loadedPlugins.set(name, failedPlugin);
+    return null;
+  }
+}
+async function unloadPlugin(name) {
+  const loaded = loadedPlugins.get(name);
+  if (!loaded) {
+    return false;
+  }
+  try {
+    if (loaded.instance.deactivate) {
+      await loaded.instance.deactivate();
+    }
+    unregisterPluginCommands(name);
+    loadedPlugins.delete(name);
+    return true;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(theme.error(`  ${symbols.cross} Failed to unload plugin '${name}': ${errorMessage}`));
+    return false;
+  }
+}
+function getDiscoveredPlugins() {
+  return Array.from(discoveredPlugins.values()).map((p) => p.manifest);
+}
+function isPluginLoaded(name) {
+  return loadedPlugins.has(name);
+}
+async function initPluginLoader() {
+  const manifests = await discoverPlugins();
+  for (const manifest of manifests) {
+    for (const cmdName of manifest.commands) {
+      const lazyExecute = async (args2) => {
+        const loaded = await loadPlugin(manifest.name);
+        if (!loaded) {
+          console.log(theme.error(`  ${symbols.cross} Failed to load plugin '${manifest.name}'`));
+          console.log(theme.dim(`  Try reinstalling: /plugin remove ${manifest.name} && /plugin install ${manifest.name}`));
+          return;
+        }
+        const realCommand = getCommand(cmdName);
+        if (realCommand && realCommand.execute !== lazyExecute) {
+          await realCommand.execute(args2);
+        } else {
+          console.log(theme.error(`  ${symbols.cross} Plugin '${manifest.name}' did not register command '${cmdName}'`));
+          console.log(theme.dim(`  The plugin may be misconfigured or corrupted.`));
+        }
+      };
+      registerPluginCommand(
+        {
+          name: cmdName,
+          description: `[${manifest.displayName || manifest.name}] Plugin command`,
+          usage: `/${cmdName}`,
+          execute: lazyExecute
+        },
+        manifest.name
+      );
+    }
+  }
+}
+
+// src/commands/plugin/list.ts
+async function listPlugins() {
+  await discoverPlugins();
+  const plugins = getDiscoveredPlugins();
+  console.log("");
+  if (plugins.length === 0) {
+    console.log(`  ${symbols.info} ${theme.dim("No plugins installed")}`);
+    console.log("");
+    console.log(`  ${theme.dim("Install a plugin with:")} ${theme.primary("/plugin install <source>")}`);
+    console.log(`  ${theme.dim("Create a new plugin with:")} ${theme.primary("/plugin create")}`);
+    console.log("");
+    return;
+  }
+  console.log(`  ${symbols.folder} ${theme.gradient("INSTALLED PLUGINS")} ${theme.dim(`(${plugins.length})`)}`);
+  console.log("");
+  for (const plugin of plugins) {
+    const loaded = isPluginLoaded(plugin.name);
+    const status = loaded ? theme.success("active") : theme.dim("idle");
+    const statusIcon = loaded ? symbols.check : symbols.bullet;
+    console.log(`  ${statusIcon} ${theme.primary(plugin.displayName || plugin.name)} ${theme.dim(`v${plugin.version}`)}`);
+    if (plugin.description) {
+      console.log(`    ${theme.dim(plugin.description)}`);
+    }
+    console.log(`    ${theme.dim("Commands:")} ${plugin.commands.map((c) => theme.accent("/" + c)).join(", ")}`);
+    if (plugin.permissions) {
+      const perms = [];
+      if (plugin.permissions.shell) perms.push("shell");
+      if (plugin.permissions.filesystem) perms.push("fs");
+      if (plugin.permissions.network) perms.push("net");
+      if (perms.length > 0) {
+        console.log(`    ${theme.dim("Permissions:")} ${theme.warning(perms.join(", "))}`);
+      }
+    }
+    console.log("");
+  }
+}
+
+// src/plugins/installer.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, cpSync, rmSync, readFileSync as readFileSync8, readdirSync as readdirSync3, createReadStream, createWriteStream } from "fs";
+import { join as join7, resolve as resolve3, dirname as dirname4 } from "path";
+import { execSync as execSync2 } from "child_process";
+import { tmpdir, platform as platform2 } from "os";
+import { createGunzip } from "zlib";
+import { pipeline } from "stream/promises";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var isWindows = platform2() === "win32";
+function getZammyVersion3() {
+  try {
+    const __filename = fileURLToPath3(import.meta.url);
+    const __dirname = dirname4(__filename);
+    const possiblePaths = [
+      join7(__dirname, "package.json"),
+      join7(__dirname, "..", "package.json"),
+      join7(__dirname, "..", "..", "package.json")
+    ];
+    for (const pkgPath of possiblePaths) {
+      if (existsSync9(pkgPath)) {
+        const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+        if (pkg.name === "zammy" && pkg.version) {
+          return pkg.version;
+        }
+      }
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function compareVersions2(a, b3) {
+  const partsA = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const partsB = b3.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+  return 0;
+}
+function checkVersionCompatibility2(manifest) {
+  const zammyVersion = getZammyVersion3();
+  const minVersion = manifest.zammy?.minVersion;
+  const maxVersion = manifest.zammy?.maxVersion;
+  if (minVersion && compareVersions2(zammyVersion, minVersion) < 0) {
+    return {
+      compatible: false,
+      reason: `Requires Zammy v${minVersion}+, but you have v${zammyVersion}`
+    };
+  }
+  if (maxVersion && compareVersions2(zammyVersion, maxVersion) > 0) {
+    return {
+      compatible: false,
+      reason: `Incompatible with Zammy v${zammyVersion} (max supported: v${maxVersion})`
+    };
+  }
+  return { compatible: true };
+}
+async function extractTarGz(tarGzPath, destDir) {
+  try {
+    execSync2(`tar -xzf "${tarGzPath}" -C "${destDir}"`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return;
+  } catch {
+  }
+  const tarPath = tarGzPath.replace(/\.tgz$|\.tar\.gz$/, ".tar");
+  await pipeline(
+    createReadStream(tarGzPath),
+    createGunzip(),
+    createWriteStream(tarPath)
+  );
+  try {
+    execSync2(`tar -xf "${tarPath}" -C "${destDir}"`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    rmSync(tarPath, { force: true });
+    return;
+  } catch {
+    rmSync(tarPath, { force: true });
+  }
+  if (isWindows) {
+    try {
+      execSync2(`powershell -Command "tar -xf '${tarPath}' -C '${destDir}'"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return;
+    } catch {
+      throw new Error(
+        "Unable to extract plugin archive. Please ensure tar is available.\nOn Windows 10+, tar should be built-in. Try running: tar --version"
+      );
+    }
+  }
+  throw new Error("Unable to extract plugin archive. Please ensure tar is installed.");
+}
+function validateManifest(manifest) {
+  const errors = [];
+  if (!manifest || typeof manifest !== "object") {
+    return { valid: false, errors: ["Manifest must be an object"] };
+  }
+  const m = manifest;
+  if (!m.name || typeof m.name !== "string") {
+    errors.push('Missing or invalid "name" field');
+  }
+  if (!m.version || typeof m.version !== "string") {
+    errors.push('Missing or invalid "version" field');
+  }
+  if (!m.main || typeof m.main !== "string") {
+    errors.push('Missing or invalid "main" field');
+  }
+  if (!m.commands || !Array.isArray(m.commands) || m.commands.length === 0) {
+    errors.push('Missing or invalid "commands" field (must be non-empty array)');
+  }
+  if (!m.zammy || typeof m.zammy !== "object") {
+    errors.push('Missing or invalid "zammy" field');
+  } else {
+    const zammy = m.zammy;
+    if (!zammy.minVersion || typeof zammy.minVersion !== "string") {
+      errors.push('Missing or invalid "zammy.minVersion" field');
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function checkConflicts(manifest) {
+  const conflicts = [];
+  for (const cmd of manifest.commands) {
+    const conflict = checkCommandConflict(cmd);
+    if (conflict.exists) {
+      if (conflict.source === "core") {
+        conflicts.push(`Command '/${cmd}' conflicts with core zammy command`);
+      } else {
+        conflicts.push(`Command '/${cmd}' conflicts with plugin '${conflict.pluginName}'`);
+      }
+    }
+  }
+  return { hasConflicts: conflicts.length > 0, conflicts };
+}
+function formatPermissions(manifest) {
+  const perms = [];
+  const p = manifest.permissions;
+  if (!p) return perms;
+  if (p.shell) {
+    perms.push(`${symbols.warning} shell: Can run system commands`);
+  }
+  if (p.filesystem) {
+    if (p.filesystem === true) {
+      perms.push(`${symbols.warning} filesystem: Full file system access`);
+    } else if (Array.isArray(p.filesystem)) {
+      perms.push(`${symbols.info} filesystem: Access to ${p.filesystem.join(", ")}`);
+    }
+  }
+  if (p.network) {
+    if (p.network === true) {
+      perms.push(`${symbols.warning} network: Full network access`);
+    } else if (Array.isArray(p.network)) {
+      perms.push(`${symbols.info} network: Access to ${p.network.join(", ")}`);
+    }
+  }
+  return perms;
+}
+async function installFromLocal(sourcePath) {
+  try {
+    const absPath = resolve3(sourcePath);
+    if (!existsSync9(absPath)) {
+      return { success: false, error: `Path not found: ${absPath}` };
+    }
+    const manifestPath = join7(absPath, "zammy-plugin.json");
+    if (!existsSync9(manifestPath)) {
+      return { success: false, error: "No zammy-plugin.json found in source directory" };
+    }
+    const manifestContent = readFileSync8(manifestPath, "utf-8");
+    let manifest;
+    try {
+      manifest = JSON.parse(manifestContent);
+    } catch {
+      return { success: false, error: "Invalid JSON in zammy-plugin.json" };
+    }
+    const validation = validateManifest(manifest);
+    if (!validation.valid) {
+      return { success: false, error: `Invalid manifest: ${validation.errors.join(", ")}` };
+    }
+    const versionCheck = checkVersionCompatibility2(manifest);
+    if (!versionCheck.compatible) {
+      return { success: false, error: versionCheck.reason };
+    }
+    const mainPath = join7(absPath, manifest.main);
+    if (!existsSync9(mainPath)) {
+      return { success: false, error: `Entry point not found: ${manifest.main}` };
+    }
+    ensurePluginsDir();
+    const targetDir = join7(getPluginsDir(), manifest.name);
+    if (existsSync9(targetDir)) {
+      rmSync(targetDir, { recursive: true, force: true });
+    }
+    cpSync(absPath, targetDir, { recursive: true });
+    return { success: true, manifest };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: message };
+  }
+}
+async function installFromNpm(packageName) {
+  const tempDir = join7(tmpdir(), `zammy-plugin-${Date.now()}`);
+  try {
+    mkdirSync3(tempDir, { recursive: true });
+    console.log(theme.dim(`  Downloading ${packageName}...`));
+    execSync2(`npm pack ${packageName} --pack-destination="${tempDir}"`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 6e4
+    });
+    const files = readdirSync3(tempDir);
+    const tarball = files.find((f) => f.endsWith(".tgz"));
+    if (!tarball) {
+      return { success: false, error: "Failed to download package" };
+    }
+    const extractDir = join7(tempDir, "extract");
+    mkdirSync3(extractDir);
+    await extractTarGz(join7(tempDir, tarball), extractDir);
+    const packageDir = join7(extractDir, "package");
+    if (!existsSync9(packageDir)) {
+      return { success: false, error: "Invalid package structure" };
+    }
+    return await installFromLocal(packageDir);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `npm install failed: ${message}` };
+  } finally {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+async function installFromGithub(repo) {
+  const tempDir = join7(tmpdir(), `zammy-plugin-${Date.now()}`);
+  try {
+    let repoPath = repo.replace(/^github:/, "");
+    let branch = "main";
+    if (repoPath.includes("#")) {
+      [repoPath, branch] = repoPath.split("#");
+    }
+    mkdirSync3(tempDir, { recursive: true });
+    console.log(theme.dim(`  Cloning ${repoPath}...`));
+    execSync2(`git clone --depth 1 --branch ${branch} https://github.com/${repoPath}.git "${tempDir}"`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 12e4
+    });
+    const pkgJsonPath = join7(tempDir, "package.json");
+    if (existsSync9(pkgJsonPath)) {
+      const pkgJson = JSON.parse(readFileSync8(pkgJsonPath, "utf-8"));
+      if (pkgJson.scripts?.build) {
+        console.log(theme.dim(`  Installing dependencies...`));
+        execSync2("npm install", { cwd: tempDir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 12e4 });
+        console.log(theme.dim(`  Building...`));
+        execSync2("npm run build", { cwd: tempDir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 12e4 });
+      }
+    }
+    return await installFromLocal(tempDir);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `GitHub install failed: ${message}` };
+  } finally {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+async function installFromGit(url) {
+  const tempDir = join7(tmpdir(), `zammy-plugin-${Date.now()}`);
+  try {
+    mkdirSync3(tempDir, { recursive: true });
+    console.log(theme.dim(`  Cloning from ${url}...`));
+    execSync2(`git clone --depth 1 "${url}" "${tempDir}"`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 12e4
+    });
+    const pkgJsonPath = join7(tempDir, "package.json");
+    if (existsSync9(pkgJsonPath)) {
+      const pkgJson = JSON.parse(readFileSync8(pkgJsonPath, "utf-8"));
+      if (pkgJson.scripts?.build) {
+        console.log(theme.dim(`  Installing dependencies...`));
+        execSync2("npm install", { cwd: tempDir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 12e4 });
+        console.log(theme.dim(`  Building...`));
+        execSync2("npm run build", { cwd: tempDir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 12e4 });
+      }
+    }
+    return await installFromLocal(tempDir);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `Git install failed: ${message}` };
+  } finally {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function removePlugin(name) {
+  try {
+    const pluginDir = join7(getPluginsDir(), name);
+    if (!existsSync9(pluginDir)) {
+      return { success: false, error: `Plugin '${name}' not found` };
+    }
+    rmSync(pluginDir, { recursive: true, force: true });
+    return { success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: message };
+  }
+}
+function detectSourceType(source) {
+  if (source.startsWith("./") || source.startsWith("/") || source.startsWith("..") || /^[A-Za-z]:/.test(source)) {
+    return "local";
+  }
+  if (source.startsWith("github:")) {
+    return "github";
+  }
+  if (source.includes("github.com")) {
+    return "github";
+  }
+  if (source.endsWith(".git") || source.startsWith("git@") || source.startsWith("git://")) {
+    return "git";
+  }
+  if (/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(source)) {
+    return "npm";
+  }
+  return "unknown";
+}
+
+// src/commands/plugin/install.ts
+import * as readline from "readline";
+async function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve6) => {
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve6(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function installPlugin(args2) {
+  const source = args2[0];
+  if (!source) {
+    console.log(theme.error(`  ${symbols.cross} No source specified`));
+    console.log("");
+    console.log(`  ${theme.primary("Usage:")} /plugin install <source>`);
+    console.log("");
+    console.log(`  ${theme.dim("Examples:")}`);
+    console.log(`    ${theme.dim("/plugin install ./my-plugin")}`);
+    console.log(`    ${theme.dim("/plugin install zammy-plugin-git")}`);
+    console.log(`    ${theme.dim("/plugin install github:user/repo")}`);
+    console.log("");
+    return;
+  }
+  console.log("");
+  console.log(`  ${symbols.rocket} ${theme.primary("Installing plugin...")}`);
+  const sourceType = detectSourceType(source);
+  if (sourceType === "unknown") {
+    console.log(theme.error(`  ${symbols.cross} Could not determine source type for: ${source}`));
+    return;
+  }
+  console.log(theme.dim(`  Source type: ${sourceType}`));
+  let result;
+  switch (sourceType) {
+    case "local":
+      result = await installFromLocal(source);
+      break;
+    case "npm":
+      result = await installFromNpm(source);
+      break;
+    case "github":
+      result = await installFromGithub(source);
+      break;
+    case "git":
+      result = await installFromGit(source);
+      break;
+    default:
+      result = { success: false, error: "Unknown source type" };
+  }
+  if (!result.success) {
+    console.log(theme.error(`  ${symbols.cross} Installation failed: ${result.error}`));
+    return;
+  }
+  const manifest = result.manifest;
+  const conflicts = checkConflicts(manifest);
+  if (conflicts.hasConflicts) {
+    console.log("");
+    console.log(theme.warning(`  ${symbols.warning} Command conflicts detected:`));
+    for (const conflict of conflicts.conflicts) {
+      console.log(`    ${theme.dim("-")} ${conflict}`);
+    }
+    console.log("");
+    const proceed = await confirm(`  ${theme.warning("Continue anyway?")}`);
+    if (!proceed) {
+      console.log(theme.dim("  Installation cancelled"));
+      return;
+    }
+  }
+  const permissions = formatPermissions(manifest);
+  if (permissions.length > 0) {
+    console.log("");
+    console.log(theme.warning(`  ${symbols.warning} Plugin requests permissions:`));
+    for (const perm of permissions) {
+      console.log(`    ${perm}`);
+    }
+    console.log("");
+  }
+  await discoverPlugins();
+  for (const cmdName of manifest.commands) {
+    if (getCommand(cmdName)) continue;
+    const lazyExecute = async (args3) => {
+      const loaded = await loadPlugin(manifest.name);
+      if (!loaded) {
+        console.log(theme.error(`  ${symbols.cross} Failed to load plugin '${manifest.name}'`));
+        return;
+      }
+      const realCommand = getCommand(cmdName);
+      if (realCommand && realCommand.execute !== lazyExecute) {
+        await realCommand.execute(args3);
+      } else {
+        console.log(theme.error(`  ${symbols.cross} Plugin '${manifest.name}' did not register command '${cmdName}'`));
+      }
+    };
+    registerPluginCommand(
+      {
+        name: cmdName,
+        description: `[${manifest.displayName || manifest.name}] ${manifest.description || "Plugin command"}`,
+        usage: `/${cmdName}`,
+        execute: lazyExecute
+      },
+      manifest.name
+    );
+  }
+  console.log("");
+  console.log(`  ${symbols.check} ${theme.success("Plugin installed successfully!")}`);
+  console.log("");
+  console.log(`  ${theme.primary(manifest.displayName || manifest.name)} ${theme.dim(`v${manifest.version}`)}`);
+  if (manifest.description) {
+    console.log(`  ${theme.dim(manifest.description)}`);
+  }
+  console.log("");
+  console.log(`  ${theme.dim("Commands added:")} ${manifest.commands.map((c) => theme.accent("/" + c)).join(", ")}`);
+  console.log("");
+}
+
+// src/commands/plugin/remove.ts
+import * as readline2 from "readline";
+async function confirm2(message) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve6) => {
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve6(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function removePluginCommand(args2) {
+  const forceIndex = args2.findIndex((a) => a === "-y" || a === "--yes");
+  const skipConfirm = forceIndex !== -1;
+  if (skipConfirm) {
+    args2.splice(forceIndex, 1);
+  }
+  const name = args2[0];
+  if (!name) {
+    console.log(theme.error(`  ${symbols.cross} No plugin name specified`));
+    console.log("");
+    console.log(`  ${theme.primary("Usage:")} /plugin remove <name>`);
+    console.log("");
+    await discoverPlugins();
+    const plugins2 = getDiscoveredPlugins();
+    if (plugins2.length > 0) {
+      console.log(`  ${theme.dim("Installed plugins:")}`);
+      for (const p of plugins2) {
+        console.log(`    ${theme.accent(p.name)}`);
+      }
+      console.log("");
+    }
+    return;
+  }
+  await discoverPlugins();
+  const plugins = getDiscoveredPlugins();
+  const plugin = plugins.find((p) => p.name === name || p.displayName?.toLowerCase() === name.toLowerCase());
+  if (!plugin) {
+    console.log(theme.error(`  ${symbols.cross} Plugin '${name}' not found`));
+    console.log("");
+    const similar = plugins.filter(
+      (p) => p.name.includes(name) || name.includes(p.name) || p.displayName?.toLowerCase().includes(name.toLowerCase())
+    );
+    if (similar.length > 0) {
+      console.log(`  ${theme.dim("Did you mean:")}`);
+      for (const p of similar) {
+        console.log(`    ${theme.accent(p.name)}`);
+      }
+      console.log("");
+    }
+    return;
+  }
+  console.log("");
+  console.log(`  ${theme.warning("About to remove:")}`);
+  console.log(`    ${theme.primary(plugin.displayName || plugin.name)} ${theme.dim(`v${plugin.version}`)}`);
+  console.log(`    ${theme.dim("Commands:")} ${plugin.commands.map((c) => "/" + c).join(", ")}`);
+  console.log("");
+  if (!skipConfirm) {
+    const proceed = await confirm2(`  ${theme.warning("Remove this plugin?")}`);
+    if (!proceed) {
+      console.log(theme.dim("  Removal cancelled"));
+      return;
+    }
+  }
+  await unloadPlugin(plugin.name);
+  const result = removePlugin(plugin.name);
+  if (!result.success) {
+    console.log(theme.error(`  ${symbols.cross} Failed to remove: ${result.error}`));
+    return;
+  }
+  await discoverPlugins();
+  console.log("");
+  console.log(`  ${symbols.check} ${theme.success("Plugin removed successfully")}`);
+  console.log("");
+}
 
-// src/handlers/dev/uuid.ts
-import { randomUUID } from "crypto";
-function generateUuids(count = 1) {
-  const safeCount = Math.min(Math.max(1, count), 10);
-  const uuids = [];
-  for (let i = 0; i < safeCount; i++) {
-    uuids.push(randomUUID());
-  }
-  return {
-    uuids,
-    count: safeCount
+// src/commands/plugin/create.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join8, resolve as resolve4 } from "path";
+import * as readline3 from "readline";
+async function prompt(message, defaultValue) {
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const suffix = defaultValue ? ` ${theme.dim(`(${defaultValue})`)}` : "";
+  return new Promise((resolvePromise) => {
+    rl.question(`  ${message}${suffix}: `, (answer) => {
+      rl.close();
+      resolvePromise(answer.trim() || defaultValue || "");
+    });
+  });
+}
+function generateManifest(name, displayName, description, commandName) {
+  return JSON.stringify({
+    name,
+    version: "1.0.0",
+    displayName,
+    description,
+    main: "./dist/index.js",
+    commands: [commandName],
+    zammy: {
+      minVersion: "1.3.0"
+    },
+    permissions: {}
+  }, null, 2);
+}
+function generatePackageJson(name, description) {
+  return JSON.stringify({
+    name,
+    version: "1.0.0",
+    description,
+    type: "module",
+    main: "dist/index.js",
+    scripts: {
+      build: "tsc",
+      dev: "tsc --watch"
+    },
+    keywords: ["zammy-plugin"],
+    devDependencies: {
+      typescript: "^5.3.0"
+    }
+  }, null, 2);
+}
+function generateTsConfig() {
+  return JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      outDir: "./dist",
+      rootDir: "./src",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      declaration: true
+    },
+    include: ["src/**/*"]
+  }, null, 2);
+}
+function generateEntryPoint(commandName, displayName) {
+  return `// ${displayName} - A zammy plugin
+
+// Plugin types (these match zammy's PluginAPI interface)
+interface Command {
+  name: string;
+  description: string;
+  usage: string;
+  execute: (args: string[]) => Promise<void>;
+}
+
+interface PluginAPI {
+  registerCommand(command: Command): void;
+  ui: {
+    theme: {
+      primary: (text: string) => string;
+      secondary: (text: string) => string;
+      accent: (text: string) => string;
+      success: (text: string) => string;
+      warning: (text: string) => string;
+      error: (text: string) => string;
+      info: (text: string) => string;
+      dim: (text: string) => string;
+      gradient: (text: string) => string;
+    };
+    symbols: {
+      check: string;
+      cross: string;
+      star: string;
+      arrow: string;
+      bullet: string;
+      folder: string;
+      file: string;
+      warning: string;
+      info: string;
+      rocket: string;
+      sparkles: string;
+    };
+  };
+  storage: {
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    delete(key: string): void;
+  };
+  log: {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+  };
+  context: {
+    pluginName: string;
+    pluginVersion: string;
+    zammyVersion: string;
+    dataDir: string;
+    cwd: string;
   };
 }
 
-// src/commands/dev/uuid.ts
-registerCommand({
-  name: "uuid",
-  description: "Generate UUID(s)",
-  usage: "/uuid [count]",
-  async execute(args2) {
-    const count = parseInt(args2[0]) || 1;
-    const result = generateUuids(count);
+interface ZammyPlugin {
+  activate(api: PluginAPI): Promise<void> | void;
+  deactivate?(): Promise<void> | void;
+}
+
+const plugin: ZammyPlugin = {
+  activate(api: PluginAPI) {
+    const { theme, symbols } = api.ui;
+
+    api.registerCommand({
+      name: '${commandName}',
+      description: 'My custom command',
+      usage: '/${commandName} [args]',
+      async execute(args: string[]) {
+        console.log('');
+        console.log(\`  \${symbols.star} \${theme.gradient('${displayName.toUpperCase()}')}\`);
+        console.log('');
+        console.log(\`  \${theme.success('Hello from ${displayName}!')}\`);
+
+        if (args.length > 0) {
+          console.log(\`  \${theme.dim('Arguments:')} \${args.join(' ')}\`);
+        }
+
+        console.log('');
+      },
+    });
+
+    api.log.info('Plugin activated!');
+  },
+
+  deactivate() {
+    // Cleanup if needed
+  },
+};
+
+export default plugin;
+`;
+}
+function generateReadme(name, displayName, description, commandName) {
+  return `# ${displayName}
+
+${description}
+
+## Installation
+
+\`\`\`bash
+/plugin install ./${name}
+\`\`\`
+
+## Usage
+
+\`\`\`bash
+/${commandName} [args]
+\`\`\`
+
+## Development
+
+\`\`\`bash
+# Build the plugin
+npm run build
+
+# Watch for changes
+npm run dev
+\`\`\`
+
+## License
+
+MIT
+`;
+}
+async function createPlugin(args2) {
+  console.log("");
+  console.log(`  ${symbols.sparkle} ${theme.gradient("CREATE NEW PLUGIN")}`);
+  console.log("");
+  let name = args2[0] || "";
+  if (!name) {
+    name = await prompt("Plugin name (e.g., my-plugin)", "zammy-plugin-example");
+  }
+  name = name.toLowerCase().replace(/\s+/g, "-");
+  if (!name.startsWith("zammy-plugin-")) {
+  }
+  const displayName = await prompt("Display name", name.replace(/^zammy-plugin-/, "").replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()));
+  const description = await prompt("Description", "A zammy plugin");
+  const commandName = await prompt("Main command name", name.replace(/^zammy-plugin-/, "").replace(/-/g, ""));
+  const targetDir = resolve4(process.cwd(), name);
+  if (existsSync10(targetDir)) {
+    console.log(theme.error(`  ${symbols.cross} Directory already exists: ${name}`));
+    return;
+  }
+  console.log("");
+  console.log(theme.dim(`  Creating plugin in ${targetDir}...`));
+  try {
+    mkdirSync4(targetDir);
+    mkdirSync4(join8(targetDir, "src"));
+    mkdirSync4(join8(targetDir, "dist"));
+    writeFileSync5(join8(targetDir, "zammy-plugin.json"), generateManifest(name, displayName, description, commandName));
+    writeFileSync5(join8(targetDir, "package.json"), generatePackageJson(name, description));
+    writeFileSync5(join8(targetDir, "tsconfig.json"), generateTsConfig());
+    writeFileSync5(join8(targetDir, "src", "index.ts"), generateEntryPoint(commandName, displayName));
+    writeFileSync5(join8(targetDir, "README.md"), generateReadme(name, displayName, description, commandName));
     console.log("");
-    console.log(`  ${symbols.sparkle} ${theme.gradient("UUID GENERATOR")} ${symbols.sparkle}`);
+    console.log(`  ${symbols.check} ${theme.success("Plugin created successfully!")}`);
     console.log("");
-    result.uuids.forEach((uuid, i) => {
-      console.log(`  ${theme.dim(`${i + 1}.`)} ${theme.primary(uuid)}`);
-    });
+    console.log(`  ${theme.primary("Next steps:")}`);
+    console.log(`    ${theme.dim("1.")} cd ${name}`);
+    console.log(`    ${theme.dim("2.")} npm install`);
+    console.log(`    ${theme.dim("3.")} npm run build`);
+    console.log(`    ${theme.dim("4.")} /plugin install ./${name}`);
     console.log("");
-    if (result.count === 1) {
-      console.log(theme.dim("  Tip: /uuid 5 generates 5 UUIDs"));
-    }
+    console.log(`  ${theme.dim("Edit")} ${theme.accent("src/index.ts")} ${theme.dim("to customize your plugin")}`);
     console.log("");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(theme.error(`  ${symbols.cross} Failed to create plugin: ${message}`));
   }
-});
-
-// src/handlers/dev/encode.ts
-var SUPPORTED_METHODS = ["base64", "url", "hex"];
-function isValidMethod(method) {
-  return SUPPORTED_METHODS.includes(method.toLowerCase());
-}
-function encodeText(text, method, direction) {
-  let output;
-  if (direction === "encode") {
-    switch (method) {
-      case "base64":
-        output = Buffer.from(text).toString("base64");
-        break;
-      case "url":
-        output = encodeURIComponent(text);
-        break;
-      case "hex":
-        output = Buffer.from(text).toString("hex");
-        break;
-    }
-  } else {
-    switch (method) {
-      case "base64":
-        output = Buffer.from(text, "base64").toString("utf-8");
-        break;
-      case "url":
-        output = decodeURIComponent(text);
-        break;
-      case "hex":
-        output = Buffer.from(text, "hex").toString("utf-8");
-        break;
-    }
-  }
-  return {
-    method: method.toUpperCase(),
-    direction,
-    input: text,
-    output
-  };
 }
 
-// src/commands/dev/encode.ts
+// src/commands/plugin/index.ts
 registerCommand({
-  name: "encode",
-  description: "Encode/decode text (base64, url, hex)",
-  usage: "/encode <method> <encode|decode> <text>",
+  name: "plugin",
+  description: "Manage zammy plugins",
+  usage: "/plugin <list|install|remove|create> [args]",
   async execute(args2) {
-    if (args2.length < 2) {
+    const subcommand = args2[0]?.toLowerCase();
+    if (!subcommand || subcommand === "help") {
       console.log("");
-      console.log(theme.error("Usage: /encode <method> <encode|decode> <text>"));
-      console.log(theme.dim(`  Methods: ${SUPPORTED_METHODS.join(", ")}`));
-      console.log(theme.dim("  Example: /encode base64 encode hello"));
-      console.log(theme.dim("  Example: /encode url decode hello%20world"));
-      console.log("");
-      return;
-    }
-    const method = args2[0].toLowerCase();
-    const action = args2[1].toLowerCase();
-    const text = args2.slice(2).join(" ");
-    if (!isValidMethod(method)) {
-      console.log(theme.error(`Unknown method: ${method}. Use ${SUPPORTED_METHODS.join(", ")}`));
-      return;
-    }
-    if (action !== "encode" && action !== "decode") {
-      console.log(theme.error(`Unknown action: ${action}. Use encode or decode`));
-      return;
-    }
-    if (!text) {
-      console.log(theme.error("Please provide text to encode/decode"));
-      return;
-    }
-    try {
-      const result = encodeText(text, method, action);
-      console.log("");
-      console.log(box.draw([
-        "",
-        `  ${symbols.sparkle} ${theme.gradient(result.method + " " + result.direction.toUpperCase())}`,
-        "",
-        `  ${theme.dim("Input:")}`,
-        `  ${theme.secondary(result.input.length > 50 ? result.input.slice(0, 50) + "..." : result.input)}`,
-        "",
-        `  ${theme.dim("Output:")}`,
-        `  ${theme.success(result.output.length > 50 ? result.output.slice(0, 50) + "..." : result.output)}`,
-        "",
-        ...result.output.length > 50 ? [`  ${theme.dim("(Full output: " + result.output.length + " chars)")}`] : [],
-        ""
-      ], 60));
+      console.log(`  ${symbols.gear} ${theme.gradient("PLUGIN MANAGER")}`);
       console.log("");
-      if (result.output.length > 50) {
-        console.log(theme.dim("  Full result:"));
-        console.log(`  ${result.output}`);
-        console.log("");
-      }
-    } catch (e) {
-      console.log(theme.error(`Failed to ${action}: Invalid input for ${method}`));
-    }
-  }
-});
-
-// src/commands/info/weather.ts
-registerCommand({
-  name: "weather",
-  description: "Get current weather for a city",
-  usage: "/weather <city>",
-  async execute(args2) {
-    const city = args2.join(" ") || "London";
-    console.log(theme.dim(`Fetching weather for ${city}...`));
-    try {
-      const response = await fetch(`https://wttr.in/${encodeURIComponent(city)}?format=j1`);
-      if (!response.ok) {
-        console.log(theme.error(`Could not fetch weather for "${city}"`));
-        return;
-      }
-      const data = await response.json();
-      const current = data.current_condition[0];
-      const location = data.nearest_area[0];
-      const temp = current.temp_C;
-      const feelsLike = current.FeelsLikeC;
-      const desc = current.weatherDesc[0].value;
-      const humidity = current.humidity;
-      const wind = current.windspeedKmph;
-      const cityName = location.areaName[0].value;
-      const country = location.country[0].value;
+      console.log(`  ${theme.primary("Usage:")} /plugin <command> [args]`);
       console.log("");
-      console.log(theme.highlight(`${cityName}, ${country}`));
+      console.log(`  ${theme.primary("Commands:")}`);
+      console.log(`    ${theme.accent("list")}              ${theme.dim("Show installed plugins")}`);
+      console.log(`    ${theme.accent("install")} <source>  ${theme.dim("Install a plugin")}`);
+      console.log(`    ${theme.accent("remove")} <name>     ${theme.dim("Remove a plugin")}`);
+      console.log(`    ${theme.accent("create")} [name]     ${theme.dim("Create a new plugin")}`);
       console.log("");
-      console.log(`  ${theme.primary(desc)}`);
-      console.log(`  Temperature: ${theme.warning(temp + "\xB0C")} (feels like ${feelsLike}\xB0C)`);
-      console.log(`  Humidity: ${humidity}%`);
-      console.log(`  Wind: ${wind} km/h`);
+      console.log(`  ${theme.primary("Install sources:")}`);
+      console.log(`    ${theme.dim("./path/to/plugin")}    ${theme.dim("Local directory")}`);
+      console.log(`    ${theme.dim("package-name")}        ${theme.dim("npm package")}`);
+      console.log(`    ${theme.dim("github:user/repo")}    ${theme.dim("GitHub repository")}`);
+      console.log(`    ${theme.dim("https://...git")}      ${theme.dim("Git URL")}`);
       console.log("");
-    } catch (error) {
-      console.log(theme.error(`Error fetching weather: ${error}`));
+      return;
+    }
+    switch (subcommand) {
+      case "list":
+      case "ls":
+        await listPlugins();
+        break;
+      case "install":
+      case "i":
+      case "add":
+        await installPlugin(args2.slice(1));
+        break;
+      case "remove":
+      case "rm":
+      case "uninstall":
+        await removePluginCommand(args2.slice(1));
+        break;
+      case "create":
+      case "new":
+      case "init":
+        await createPlugin(args2.slice(1));
+        break;
+      default:
+        console.log(theme.error(`  ${symbols.cross} Unknown subcommand: ${subcommand}`));
+        console.log(theme.dim(`  Use '/plugin help' to see available commands`));
     }
   }
 });
 
 // src/cli.ts
-import { exec, execSync, spawn } from "child_process";
-import { existsSync as existsSync4, statSync, readFileSync as readFileSync3, readdirSync, writeFileSync as writeFileSync3, watchFile, unwatchFile } from "fs";
-import { resolve as resolve2, extname, basename, join as join3 } from "path";
-import { homedir as homedir3, platform as platform2, networkInterfaces } from "os";
-import chalk3 from "chalk";
-var isWindows = platform2() === "win32";
+import { exec, execSync as execSync3, spawn } from "child_process";
+import { existsSync as existsSync11, statSync as statSync2, readFileSync as readFileSync9, readdirSync as readdirSync4, writeFileSync as writeFileSync6, watchFile, unwatchFile } from "fs";
+import { resolve as resolve5, extname, basename as basename4, join as join9 } from "path";
+import { homedir as homedir5, platform as platform3, networkInterfaces } from "os";
+import chalk5 from "chalk";
+var isWindows2 = platform3() === "win32";
 function translateCommand(cmd) {
-  if (!isWindows) return cmd;
+  if (!isWindows2) return cmd;
   const parts = cmd.trim().split(/\s+/);
   const command = parts[0].toLowerCase();
   const args2 = parts.slice(1);
@@ -2514,42 +5180,42 @@ function translateCommand(cmd) {
 function handleCd(args2) {
   let targetPath = args2.trim();
   if (!targetPath || targetPath === "~") {
-    targetPath = homedir3();
+    targetPath = homedir5();
   } else if (targetPath.startsWith("~/")) {
-    targetPath = resolve2(homedir3(), targetPath.slice(2));
+    targetPath = resolve5(homedir5(), targetPath.slice(2));
   } else if (targetPath === "-") {
     console.log(theme.dim(process.cwd()));
     return;
   } else {
-    targetPath = resolve2(process.cwd(), targetPath);
+    targetPath = resolve5(process.cwd(), targetPath);
   }
-  if (!existsSync4(targetPath)) {
-    console.log(theme.error(`Directory not found: ${targetPath}`));
+  if (!existsSync11(targetPath)) {
+    console.log(`${miniSlime.sad} ${theme.error(`Directory not found: ${targetPath}`)}`);
     return;
   }
   try {
-    const stats = statSync(targetPath);
+    const stats = statSync2(targetPath);
     if (!stats.isDirectory()) {
-      console.log(theme.error(`Not a directory: ${targetPath}`));
+      console.log(`${miniSlime.sad} ${theme.error(`Not a directory: ${targetPath}`)}`);
       return;
     }
     process.chdir(targetPath);
     console.log(theme.dim(process.cwd()));
   } catch (error) {
-    console.log(theme.error(`Cannot access: ${targetPath}`));
+    console.log(`${miniSlime.sad} ${theme.error(`Cannot access: ${targetPath}`)}`);
   }
 }
 function handlePwd() {
   console.log(theme.primary(process.cwd()));
 }
 function handleCat(args2) {
-  const filePath = resolve2(process.cwd(), args2.trim());
-  if (!existsSync4(filePath)) {
-    console.log(theme.error(`File not found: ${args2}`));
+  const filePath = resolve5(process.cwd(), args2.trim());
+  if (!existsSync11(filePath)) {
+    console.log(`${miniSlime.sad} ${theme.error(`File not found: ${args2}`)}`);
     return;
   }
   try {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const ext = extname(filePath).toLowerCase();
     if ([".js", ".ts", ".jsx", ".tsx", ".json", ".css", ".html", ".py", ".go", ".rs"].includes(ext)) {
       console.log(highlightSyntax(content, ext));
@@ -2557,7 +5223,7 @@ function handleCat(args2) {
       console.log(content);
     }
   } catch (error) {
-    console.log(theme.error(`Cannot read file: ${args2}`));
+    console.log(`${miniSlime.sad} ${theme.error(`Cannot read file: ${args2}`)}`);
   }
 }
 function highlightSyntax(content, ext) {
@@ -2567,12 +5233,12 @@ function highlightSyntax(content, ext) {
   };
   const kw = ext === ".py" ? keywords.py : keywords.js;
   return content.split("\n").map((line) => {
-    line = line.replace(/(["'`])(?:(?!\1)[^\\]|\\.)*?\1/g, (match) => chalk3.hex("#98C379")(match));
-    line = line.replace(/(\/\/.*$|#.*$)/g, (match) => chalk3.hex("#5C6370")(match));
-    line = line.replace(/\b(\d+\.?\d*)\b/g, (match) => chalk3.hex("#D19A66")(match));
+    line = line.replace(/(["'`])(?:(?!\1)[^\\]|\\.)*?\1/g, (match) => chalk5.hex("#98C379")(match));
+    line = line.replace(/(\/\/.*$|#.*$)/g, (match) => chalk5.hex("#5C6370")(match));
+    line = line.replace(/\b(\d+\.?\d*)\b/g, (match) => chalk5.hex("#D19A66")(match));
     kw.forEach((keyword) => {
       const regex = new RegExp(`\\b(${keyword})\\b`, "g");
-      line = line.replace(regex, chalk3.hex("#C678DD")(keyword));
+      line = line.replace(regex, chalk5.hex("#C678DD")(keyword));
     });
     return line;
   }).join("\n");
@@ -2637,24 +5303,24 @@ var fileIcons = {
   "default": { icon: "\u{1F4C4}", color: "#6C7A89" }
 };
 function formatSize(bytes) {
-  if (bytes === 0) return chalk3.dim("    0 B");
+  if (bytes === 0) return chalk5.dim("    0 B");
   const units = ["B", "KB", "MB", "GB", "TB"];
   const i = Math.floor(Math.log(bytes) / Math.log(1024));
   const size = (bytes / Math.pow(1024, i)).toFixed(i > 0 ? 1 : 0);
-  return chalk3.hex("#98C379")(size.padStart(5) + " " + units[i].padEnd(2));
+  return chalk5.hex("#98C379")(size.padStart(5) + " " + units[i].padEnd(2));
 }
 function handleLs(args2) {
   const parts = args2.trim().split(/\s+/).filter(Boolean);
   const showAll = parts.some((a) => a === "-a" || a === "-la" || a === "-al");
   const showLong = parts.some((a) => a === "-l" || a === "-la" || a === "-al");
   const pathArgs = parts.filter((a) => !a.startsWith("-"));
-  const targetPath = pathArgs.length > 0 ? resolve2(process.cwd(), pathArgs[0]) : process.cwd();
-  if (!existsSync4(targetPath)) {
+  const targetPath = pathArgs.length > 0 ? resolve5(process.cwd(), pathArgs[0]) : process.cwd();
+  if (!existsSync11(targetPath)) {
     console.log(theme.error(`Directory not found: ${targetPath}`));
     return;
   }
   try {
-    const entries = readdirSync(targetPath, { withFileTypes: true });
+    const entries = readdirSync4(targetPath, { withFileTypes: true });
     const filtered = showAll ? entries : entries.filter((e) => !e.name.startsWith("."));
     console.log("");
     console.log(theme.dim(`  ${targetPath}`));
@@ -2664,28 +5330,28 @@ function handleLs(args2) {
       console.log("");
       return;
     }
-    const sorted = filtered.sort((a, b) => {
-      if (a.isDirectory() && !b.isDirectory()) return -1;
-      if (!a.isDirectory() && b.isDirectory()) return 1;
-      return a.name.localeCompare(b.name);
+    const sorted = filtered.sort((a, b3) => {
+      if (a.isDirectory() && !b3.isDirectory()) return -1;
+      if (!a.isDirectory() && b3.isDirectory()) return 1;
+      return a.name.localeCompare(b3.name);
     });
     for (const entry of sorted) {
-      const fullPath = resolve2(targetPath, entry.name);
+      const fullPath = resolve5(targetPath, entry.name);
       const isDir = entry.isDirectory();
       const ext = isDir ? "dir" : extname(entry.name).toLowerCase();
       const iconInfo = fileIcons[ext] || fileIcons["default"];
       let line = `  ${iconInfo.icon} `;
       if (showLong) {
         try {
-          const stats = statSync(fullPath);
-          const size = isDir ? chalk3.dim("   <DIR>") : formatSize(stats.size);
+          const stats = statSync2(fullPath);
+          const size = isDir ? chalk5.dim("   <DIR>") : formatSize(stats.size);
           const date = stats.mtime.toLocaleDateString("en-US", { month: "short", day: "2-digit", year: "numeric" });
-          line += chalk3.dim(date.padEnd(13)) + size + "  ";
+          line += chalk5.dim(date.padEnd(13)) + size + "  ";
         } catch {
-          line += chalk3.dim("             ") + "          ";
+          line += chalk5.dim("             ") + "          ";
         }
       }
-      const name = isDir ? chalk3.hex(iconInfo.color).bold(entry.name + "/") : chalk3.hex(iconInfo.color)(entry.name);
+      const name = isDir ? chalk5.hex(iconInfo.color).bold(entry.name + "/") : chalk5.hex(iconInfo.color)(entry.name);
       line += name;
       console.log(line);
     }
@@ -2699,22 +5365,22 @@ function handleLs(args2) {
 function handleTree(args2, maxDepth = 3) {
   const parts = args2.trim().split(/\s+/).filter(Boolean);
   const pathArgs = parts.filter((a) => !a.startsWith("-"));
-  const targetPath = pathArgs.length > 0 ? resolve2(process.cwd(), pathArgs[0]) : process.cwd();
-  if (!existsSync4(targetPath)) {
+  const targetPath = pathArgs.length > 0 ? resolve5(process.cwd(), pathArgs[0]) : process.cwd();
+  if (!existsSync11(targetPath)) {
     console.log(theme.error(`Directory not found: ${targetPath}`));
     return;
   }
   console.log("");
-  console.log(theme.primary(`  \u{1F4C1} ${basename(targetPath)}/`));
+  console.log(theme.primary(`  \u{1F4C1} ${basename4(targetPath)}/`));
   let dirCount = 0;
   let fileCount = 0;
   function printTree(dir, prefix, depth) {
     if (depth > maxDepth) return;
     try {
-      const entries = readdirSync(dir, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && !["node_modules", ".git", "dist", "build"].includes(e.name)).sort((a, b) => {
-        if (a.isDirectory() && !b.isDirectory()) return -1;
-        if (!a.isDirectory() && b.isDirectory()) return 1;
-        return a.name.localeCompare(b.name);
+      const entries = readdirSync4(dir, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && !["node_modules", ".git", "dist", "build"].includes(e.name)).sort((a, b3) => {
+        if (a.isDirectory() && !b3.isDirectory()) return -1;
+        if (!a.isDirectory() && b3.isDirectory()) return 1;
+        return a.name.localeCompare(b3.name);
       });
       entries.forEach((entry, index) => {
         const isLast = index === entries.length - 1;
@@ -2723,11 +5389,11 @@ function handleTree(args2, maxDepth = 3) {
         const iconInfo = fileIcons[ext] || fileIcons["default"];
         if (entry.isDirectory()) {
           dirCount++;
-          console.log(theme.dim(prefix + connector) + iconInfo.icon + " " + chalk3.hex(iconInfo.color).bold(entry.name + "/"));
-          printTree(resolve2(dir, entry.name), prefix + (isLast ? "    " : "\u2502   "), depth + 1);
+          console.log(theme.dim(prefix + connector) + iconInfo.icon + " " + chalk5.hex(iconInfo.color).bold(entry.name + "/"));
+          printTree(resolve5(dir, entry.name), prefix + (isLast ? "    " : "\u2502   "), depth + 1);
         } else {
           fileCount++;
-          console.log(theme.dim(prefix + connector) + iconInfo.icon + " " + chalk3.hex(iconInfo.color)(entry.name));
+          console.log(theme.dim(prefix + connector) + iconInfo.icon + " " + chalk5.hex(iconInfo.color)(entry.name));
         }
       });
     } catch {
@@ -2738,18 +5404,18 @@ function handleTree(args2, maxDepth = 3) {
   console.log(theme.dim(`  ${dirCount} directories, ${fileCount} files`));
   console.log("");
 }
-var bookmarksFile = join3(homedir3(), ".zammy-bookmarks.json");
+var bookmarksFile = join9(homedir5(), ".zammy-bookmarks.json");
 function loadBookmarks() {
   try {
-    if (existsSync4(bookmarksFile)) {
-      return JSON.parse(readFileSync3(bookmarksFile, "utf-8"));
+    if (existsSync11(bookmarksFile)) {
+      return JSON.parse(readFileSync9(bookmarksFile, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveBookmarks(bookmarks) {
-  writeFileSync3(bookmarksFile, JSON.stringify(bookmarks, null, 2));
+  writeFileSync6(bookmarksFile, JSON.stringify(bookmarks, null, 2));
 }
 function handleBookmark(args2) {
   const parts = args2.trim().split(/\s+/);
@@ -2761,38 +5427,38 @@ function handleBookmark(args2) {
     case "save":
     case "add":
       if (!name) {
-        console.log(theme.error("  Usage: bookmark save <name>"));
+        console.log(`  ${miniSlime.thinking} ${theme.error("Usage: bookmark save <name>")}`);
         break;
       }
       bookmarks[name] = process.cwd();
       saveBookmarks(bookmarks);
-      console.log(`  ${symbols.check} ${theme.success("Saved bookmark:")} ${theme.primary(name)} ${theme.dim("\u2192")} ${process.cwd()}`);
+      console.log(`  ${miniSlime.happy} ${theme.success("Saved bookmark:")} ${theme.primary(name)} ${theme.dim("\u2192")} ${process.cwd()}`);
       break;
     case "go":
     case "cd":
       if (!name || !bookmarks[name]) {
-        console.log(theme.error(`  Bookmark not found: ${name}`));
+        console.log(`  ${miniSlime.sad} ${theme.error(`Bookmark not found: ${name}`)}`);
         console.log(theme.dim('  Use "bookmark list" to see all bookmarks'));
         break;
       }
       try {
         process.chdir(bookmarks[name]);
-        console.log(`  ${symbols.check} ${theme.dim("Jumped to")} ${theme.primary(name)}`);
+        console.log(`  ${miniSlime.excited} ${theme.dim("Jumped to")} ${theme.primary(name)}`);
         console.log(`  ${theme.dim(process.cwd())}`);
       } catch {
-        console.log(theme.error(`  Cannot access: ${bookmarks[name]}`));
+        console.log(`  ${miniSlime.sad} ${theme.error(`Cannot access: ${bookmarks[name]}`)}`);
       }
       break;
     case "del":
     case "delete":
     case "rm":
       if (!name || !bookmarks[name]) {
-        console.log(theme.error(`  Bookmark not found: ${name}`));
+        console.log(`  ${miniSlime.sad} ${theme.error(`Bookmark not found: ${name}`)}`);
         break;
       }
       delete bookmarks[name];
       saveBookmarks(bookmarks);
-      console.log(`  ${symbols.check} ${theme.success("Deleted bookmark:")} ${theme.primary(name)}`);
+      console.log(`  ${miniSlime.happy} ${theme.success("Deleted bookmark:")} ${theme.primary(name)}`);
       break;
     case "list":
     case "ls":
@@ -2805,7 +5471,7 @@ function handleBookmark(args2) {
         console.log(theme.primary("  \u{1F4CD} Directory Bookmarks"));
         console.log("");
         for (const key of keys.sort()) {
-          const exists = existsSync4(bookmarks[key]);
+          const exists = existsSync11(bookmarks[key]);
           const status = exists ? theme.success(symbols.check) : theme.error(symbols.cross);
           console.log(`  ${status} ${theme.primary(key.padEnd(15))} ${theme.dim("\u2192")} ${bookmarks[key]}`);
         }
@@ -2822,10 +5488,10 @@ function handleFind(args2) {
   function searchDir(dir, depth = 0) {
     if (depth > 5 || results.length >= maxResults) return;
     try {
-      const entries = readdirSync(dir, { withFileTypes: true });
+      const entries = readdirSync4(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name.startsWith(".") || ["node_modules", ".git", "dist", "build"].includes(entry.name)) continue;
-        const fullPath = resolve2(dir, entry.name);
+        const fullPath = resolve5(dir, entry.name);
         const matchPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
         const regex = new RegExp(matchPattern, "i");
         if (regex.test(entry.name)) {
@@ -2849,9 +5515,9 @@ function handleFind(args2) {
       const relativePath = result.path.replace(searchPath, ".").replace(/\\/g, "/");
       const ext = result.isDir ? "dir" : extname(result.path).toLowerCase();
       const iconInfo = fileIcons[ext] || fileIcons["default"];
-      const fileName = basename(result.path);
+      const fileName = basename4(result.path);
       const dirPath = relativePath.slice(0, -fileName.length);
-      console.log(`  ${iconInfo.icon} ${theme.dim(dirPath)}${chalk3.hex(iconInfo.color)(fileName)}${result.isDir ? "/" : ""}`);
+      console.log(`  ${iconInfo.icon} ${theme.dim(dirPath)}${chalk5.hex(iconInfo.color)(fileName)}${result.isDir ? "/" : ""}`);
     }
     if (results.length >= maxResults) {
       console.log("");
@@ -2861,8 +5527,8 @@ function handleFind(args2) {
   console.log("");
 }
 function handleDu(args2) {
-  const targetPath = args2.trim() ? resolve2(process.cwd(), args2.trim()) : process.cwd();
-  if (!existsSync4(targetPath)) {
+  const targetPath = args2.trim() ? resolve5(process.cwd(), args2.trim()) : process.cwd();
+  if (!existsSync11(targetPath)) {
     console.log(theme.error(`  Path not found: ${targetPath}`));
     return;
   }
@@ -2870,10 +5536,10 @@ function handleDu(args2) {
   console.log("");
   console.log(theme.dim("  Calculating sizes..."));
   try {
-    const entries = readdirSync(targetPath, { withFileTypes: true });
+    const entries = readdirSync4(targetPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const fullPath = resolve2(targetPath, entry.name);
+      const fullPath = resolve5(targetPath, entry.name);
       let size = 0;
       let skipped = false;
       try {
@@ -2882,10 +5548,10 @@ function handleDu(args2) {
             skipped = true;
             size = 0;
           } else {
-            size = getDirSize(fullPath);
+            size = getDirSize2(fullPath);
           }
         } else {
-          size = statSync(fullPath).size;
+          size = statSync2(fullPath).size;
         }
         items.push({ name: entry.name, size, isDir: entry.isDirectory(), skipped });
       } catch {
@@ -2896,10 +5562,10 @@ function handleDu(args2) {
     return;
   }
   process.stdout.write("\x1B[1A\x1B[2K");
-  items.sort((a, b) => b.size - a.size);
+  items.sort((a, b3) => b3.size - a.size);
   const totalSize = items.reduce((sum, item) => sum + item.size, 0);
   console.log("");
-  console.log(theme.primary(`  \u{1F4CA} Disk Usage: ${basename(targetPath)}`));
+  console.log(theme.primary(`  \u{1F4CA} Disk Usage: ${basename4(targetPath)}`));
   console.log(theme.dim(`  Total: ${formatSizeSimple(totalSize)}`));
   console.log("");
   const maxItems = 15;
@@ -2913,10 +5579,10 @@ function handleDu(args2) {
     const percent = totalSize > 0 ? item.size / totalSize * 100 : 0;
     const barWidth = 20;
     const filled = Math.round(percent / 100 * barWidth);
-    const bar = chalk3.hex("#4ECDC4")("\u2588".repeat(filled)) + chalk3.dim("\u2591".repeat(barWidth - filled));
+    const bar = chalk5.hex("#4ECDC4")("\u2588".repeat(filled)) + chalk5.dim("\u2591".repeat(barWidth - filled));
     const icon = item.isDir ? "\u{1F4C1}" : "\u{1F4C4}";
     const name = item.name.length > 25 ? item.name.slice(0, 22) + "..." : item.name.padEnd(25);
-    console.log(`  ${icon} ${name} ${bar} ${formatSizeSimple(item.size).padStart(8)} ${chalk3.dim(`${percent.toFixed(1)}%`)}`);
+    console.log(`  ${icon} ${name} ${bar} ${formatSizeSimple(item.size).padStart(8)} ${chalk5.dim(`${percent.toFixed(1)}%`)}`);
   }
   if (items.length > maxItems) {
     console.log(theme.dim(`  ... and ${items.length - maxItems} more items`));
@@ -2928,19 +5594,19 @@ function handleDu(args2) {
   console.log("");
 }
 var skipDirs = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".nuxt", "coverage", ".cache", "__pycache__", "venv", ".venv"]);
-function getDirSize(dir, depth = 0, maxDepth = 4) {
+function getDirSize2(dir, depth = 0, maxDepth = 4) {
   if (depth > maxDepth) return 0;
   let size = 0;
   try {
-    const entries = readdirSync(dir, { withFileTypes: true });
+    const entries = readdirSync4(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (skipDirs.has(entry.name)) continue;
-      const fullPath = resolve2(dir, entry.name);
+      const fullPath = resolve5(dir, entry.name);
       if (entry.isDirectory()) {
-        size += getDirSize(fullPath, depth + 1, maxDepth);
+        size += getDirSize2(fullPath, depth + 1, maxDepth);
       } else {
         try {
-          size += statSync(fullPath).size;
+          size += statSync2(fullPath).size;
         } catch {
         }
       }
@@ -2959,7 +5625,7 @@ function handleGit(args2) {
   const subcommand = args2.trim().split(/\s+/)[0] || "status";
   console.log("");
   try {
-    execSync("git rev-parse --is-inside-work-tree", { stdio: "pipe", timeout: 5e3 });
+    execSync3("git rev-parse --is-inside-work-tree", { stdio: "pipe", timeout: 5e3 });
   } catch {
     console.log(theme.error("  Not a git repository"));
     console.log("");
@@ -2969,10 +5635,10 @@ function handleGit(args2) {
     switch (subcommand) {
       case "status":
       case "s": {
-        const branch = execSync("git branch --show-current", { encoding: "utf-8", timeout: 5e3 }).trim();
-        console.log(`  ${symbols.rocket} ${theme.primary("Branch:")} ${chalk3.hex("#98C379")(branch)}`);
+        const branch = execSync3("git branch --show-current", { encoding: "utf-8", timeout: 5e3 }).trim();
+        console.log(`  ${symbols.rocket} ${theme.primary("Branch:")} ${chalk5.hex("#98C379")(branch)}`);
         console.log("");
-        const status = execSync("git status --porcelain", { encoding: "utf-8", timeout: 5e3 });
+        const status = execSync3("git status --porcelain", { encoding: "utf-8", timeout: 5e3 });
         if (!status.trim()) {
           console.log(`  ${symbols.check} ${theme.success("Working tree clean")}`);
         } else {
@@ -2995,12 +5661,12 @@ function handleGit(args2) {
           }
           if (staged.length > 0) {
             console.log(theme.success("  Staged changes:"));
-            staged.forEach((f) => console.log(`    ${symbols.check} ${chalk3.hex("#98C379")(f)}`));
+            staged.forEach((f) => console.log(`    ${symbols.check} ${chalk5.hex("#98C379")(f)}`));
             console.log("");
           }
           if (modified.length > 0) {
             console.log(theme.warning("  Modified:"));
-            modified.forEach((f) => console.log(`    ${symbols.bullet} ${chalk3.hex("#E5C07B")(f)}`));
+            modified.forEach((f) => console.log(`    ${symbols.bullet} ${chalk5.hex("#E5C07B")(f)}`));
             console.log("");
           }
           if (untracked.length > 0) {
@@ -3009,35 +5675,35 @@ function handleGit(args2) {
             console.log("");
           }
         }
-        const log = execSync("git log --oneline -3", { encoding: "utf-8", timeout: 3e3 }).trim();
+        const log = execSync3("git log --oneline -3", { encoding: "utf-8", timeout: 3e3 }).trim();
         if (log) {
           console.log(theme.dim("  Recent commits:"));
           log.split("\n").forEach((line) => {
             const [hash, ...msg] = line.split(" ");
-            console.log(`    ${chalk3.hex("#61AFEF")(hash)} ${theme.dim(msg.join(" "))}`);
+            console.log(`    ${chalk5.hex("#61AFEF")(hash)} ${theme.dim(msg.join(" "))}`);
           });
         }
         break;
       }
       case "log":
       case "l": {
-        const log = execSync("git log --oneline -10", { encoding: "utf-8", timeout: 3e3 }).trim();
+        const log = execSync3("git log --oneline -10", { encoding: "utf-8", timeout: 3e3 }).trim();
         console.log(theme.primary("  \u{1F4DC} Recent Commits"));
         console.log("");
         log.split("\n").forEach((line) => {
           const [hash, ...msg] = line.split(" ");
-          console.log(`  ${chalk3.hex("#61AFEF")(hash)} ${msg.join(" ")}`);
+          console.log(`  ${chalk5.hex("#61AFEF")(hash)} ${msg.join(" ")}`);
         });
         break;
       }
       case "branch":
       case "b": {
-        const branches = execSync("git branch -a", { encoding: "utf-8", timeout: 3e3 }).trim();
+        const branches = execSync3("git branch -a", { encoding: "utf-8", timeout: 3e3 }).trim();
         console.log(theme.primary("  \u{1F33F} Branches"));
         console.log("");
         branches.split("\n").forEach((line) => {
           if (line.startsWith("*")) {
-            console.log(`  ${chalk3.hex("#98C379")(line)}`);
+            console.log(`  ${chalk5.hex("#98C379")(line)}`);
           } else {
             console.log(`  ${theme.dim(line)}`);
           }
@@ -3045,7 +5711,7 @@ function handleGit(args2) {
         break;
       }
       default:
-        const result = execSync(`git ${args2}`, { encoding: "utf-8", timeout: 1e4 });
+        const result = execSync3(`git ${args2}`, { encoding: "utf-8", timeout: 1e4 });
         console.log(result);
     }
   } catch (error) {
@@ -3054,23 +5720,23 @@ function handleGit(args2) {
   }
   console.log("");
 }
-var isMac = platform2() === "darwin";
-var isLinux = platform2() === "linux";
+var isMac = platform3() === "darwin";
+var isLinux = platform3() === "linux";
 function getClipboardCopyCmd() {
-  if (isWindows) return "clip";
+  if (isWindows2) return "clip";
   if (isMac) return "pbcopy";
   try {
-    execSync("which xclip", { stdio: "pipe" });
+    execSync3("which xclip", { stdio: "pipe" });
     return "xclip -selection clipboard";
   } catch {
     return "xsel --clipboard --input";
   }
 }
 function getClipboardPasteCmd() {
-  if (isWindows) return 'powershell -command "Get-Clipboard"';
+  if (isWindows2) return 'powershell -command "Get-Clipboard"';
   if (isMac) return "pbpaste";
   try {
-    execSync("which xclip", { stdio: "pipe" });
+    execSync3("which xclip", { stdio: "pipe" });
     return "xclip -selection clipboard -o";
   } catch {
     return "xsel --clipboard --output";
@@ -3084,10 +5750,10 @@ function handleClipboard(args2) {
   if (action === "copy" && content) {
     try {
       const copyCmd = getClipboardCopyCmd();
-      if (isWindows) {
-        execSync(`echo ${content} | ${copyCmd}`, { stdio: "pipe", timeout: 3e3 });
+      if (isWindows2) {
+        execSync3(`echo ${content} | ${copyCmd}`, { stdio: "pipe", timeout: 3e3 });
       } else {
-        execSync(`echo "${content}" | ${copyCmd}`, { stdio: "pipe", timeout: 3e3 });
+        execSync3(`echo "${content}" | ${copyCmd}`, { stdio: "pipe", timeout: 3e3 });
       }
       console.log(`  ${symbols.check} ${theme.success("Copied to clipboard")}`);
     } catch {
@@ -3099,7 +5765,7 @@ function handleClipboard(args2) {
   } else if (action === "paste") {
     try {
       const pasteCmd = getClipboardPasteCmd();
-      const result = execSync(pasteCmd, { encoding: "utf-8", timeout: 3e3 }).trim();
+      const result = execSync3(pasteCmd, { encoding: "utf-8", timeout: 3e3 }).trim();
       console.log(`  ${symbols.clipboard} ${theme.dim("Clipboard contents:")}`);
       console.log("");
       console.log(result);
@@ -3110,14 +5776,14 @@ function handleClipboard(args2) {
       }
     }
   } else if (action === "file" && parts[1]) {
-    const filePath = resolve2(process.cwd(), parts[1]);
-    if (existsSync4(filePath)) {
+    const filePath = resolve5(process.cwd(), parts[1]);
+    if (existsSync11(filePath)) {
       try {
         const copyCmd = getClipboardCopyCmd();
-        if (isWindows) {
-          execSync(`type "${filePath}" | ${copyCmd}`, { stdio: "pipe", timeout: 5e3 });
+        if (isWindows2) {
+          execSync3(`type "${filePath}" | ${copyCmd}`, { stdio: "pipe", timeout: 5e3 });
         } else {
-          execSync(`cat "${filePath}" | ${copyCmd}`, { stdio: "pipe", timeout: 5e3 });
+          execSync3(`cat "${filePath}" | ${copyCmd}`, { stdio: "pipe", timeout: 5e3 });
         }
         console.log(`  ${symbols.check} ${theme.success("File contents copied to clipboard")}`);
       } catch {
@@ -3143,14 +5809,14 @@ function handleClipboard(args2) {
   console.log("");
 }
 function handlePretty(args2) {
-  const filePath = resolve2(process.cwd(), args2.trim());
-  if (!existsSync4(filePath)) {
+  const filePath = resolve5(process.cwd(), args2.trim());
+  if (!existsSync11(filePath)) {
     console.log(theme.error(`  File not found: ${args2}`));
     return;
   }
   console.log("");
   try {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const ext = extname(filePath).toLowerCase();
     if (ext === ".json") {
       const parsed = JSON.parse(content);
@@ -3166,7 +5832,7 @@ function handlePretty(args2) {
   console.log("");
 }
 function highlightJson(json) {
-  return json.replace(/"([^"]+)":/g, (_, key) => chalk3.hex("#E06C75")(`"${key}"`) + ":").replace(/: "([^"]*)"/g, (_, val) => ": " + chalk3.hex("#98C379")(`"${val}"`)).replace(/: (\d+)/g, (_, num) => ": " + chalk3.hex("#D19A66")(num)).replace(/: (true|false)/g, (_, bool) => ": " + chalk3.hex("#56B6C2")(bool)).replace(/: (null)/g, (_, n) => ": " + chalk3.hex("#C678DD")(n));
+  return json.replace(/"([^"]+)":/g, (_, key) => chalk5.hex("#E06C75")(`"${key}"`) + ":").replace(/: "([^"]*)"/g, (_, val) => ": " + chalk5.hex("#98C379")(`"${val}"`)).replace(/: (\d+)/g, (_, num) => ": " + chalk5.hex("#D19A66")(num)).replace(/: (true|false)/g, (_, bool) => ": " + chalk5.hex("#56B6C2")(bool)).replace(/: (null)/g, (_, n) => ": " + chalk5.hex("#C678DD")(n));
 }
 var activeWatcher = null;
 function handleWatch(args2) {
@@ -3197,14 +5863,14 @@ function handleWatch(args2) {
     console.log("");
     return;
   }
-  const filePath = resolve2(process.cwd(), action);
-  if (!existsSync4(filePath)) {
+  const filePath = resolve5(process.cwd(), action);
+  if (!existsSync11(filePath)) {
     console.log(theme.error(`  File not found: ${action}`));
     console.log("");
     return;
   }
   try {
-    const stats = statSync(filePath);
+    const stats = statSync2(filePath);
     if (stats.isDirectory()) {
       console.log(theme.error(`  Cannot watch a directory: ${action}`));
       console.log(theme.dim("  Please specify a file path"));
@@ -3220,12 +5886,12 @@ function handleWatch(args2) {
     unwatchFile(activeWatcher);
   }
   activeWatcher = filePath;
-  let lastSize = statSync(filePath).size;
+  let lastSize = statSync2(filePath).size;
   console.log(`  ${symbols.info} ${theme.primary("Watching:")} ${filePath}`);
   console.log(theme.dim('  (Type "!watch stop" to stop watching)'));
   console.log("");
   try {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const lines = content.split("\n").slice(-10);
     lines.forEach((line) => console.log(theme.dim(line)));
   } catch {
@@ -3234,12 +5900,12 @@ function handleWatch(args2) {
   watchFile(filePath, { interval: 500 }, (curr, prev) => {
     if (curr.size > lastSize) {
       try {
-        const newContent = readFileSync3(filePath, "utf-8");
+        const newContent = readFileSync9(filePath, "utf-8");
         const allLines = newContent.split("\n");
         const oldLines = Math.floor(prev.size / 50);
         const newLines = allLines.slice(-Math.max(1, allLines.length - oldLines));
         newLines.forEach((line) => {
-          if (line.trim()) console.log(chalk3.hex("#98C379")(line));
+          if (line.trim()) console.log(chalk5.hex("#98C379")(line));
         });
       } catch {
       }
@@ -3252,12 +5918,12 @@ function handleServe(args2) {
   console.log("");
   console.log(`  ${symbols.rocket} ${theme.primary("Starting HTTP server...")}`);
   console.log(`  ${theme.dim("Serving:")} ${process.cwd()}`);
-  console.log(`  ${theme.dim("URL:")} ${chalk3.hex("#61AFEF")(`http://localhost:${port}`)}`);
+  console.log(`  ${theme.dim("URL:")} ${chalk5.hex("#61AFEF")(`http://localhost:${port}`)}`);
   console.log("");
   console.log(theme.dim("  Press Ctrl+C to stop"));
   console.log("");
   try {
-    const npx = isWindows ? "npx.cmd" : "npx";
+    const npx = isWindows2 ? "npx.cmd" : "npx";
     spawn(npx, ["serve", "-p", String(port)], {
       cwd: process.cwd(),
       stdio: "inherit"
@@ -3272,8 +5938,8 @@ function handlePs() {
   console.log("");
   try {
     let result;
-    if (isWindows) {
-      result = execSync('tasklist /FO CSV /NH | findstr /V "System Idle"', { encoding: "utf-8", timeout: 5e3 });
+    if (isWindows2) {
+      result = execSync3('tasklist /FO CSV /NH | findstr /V "System Idle"', { encoding: "utf-8", timeout: 5e3 });
       const lines = result.trim().split("\n").slice(0, 15);
       console.log(theme.dim("  Name                          PID       Memory"));
       console.log(theme.dim("  \u2500".repeat(25)));
@@ -3283,11 +5949,11 @@ function handlePs() {
           const name = parts[0].slice(0, 28).padEnd(30);
           const pid = parts[1].padStart(8);
           const mem = parts[4];
-          console.log(`  ${name}${pid}  ${chalk3.hex("#98C379")(mem)}`);
+          console.log(`  ${name}${pid}  ${chalk5.hex("#98C379")(mem)}`);
         }
       });
     } else {
-      result = execSync("ps aux | head -15", { encoding: "utf-8", timeout: 5e3 });
+      result = execSync3("ps aux | head -15", { encoding: "utf-8", timeout: 5e3 });
       console.log(result);
     }
   } catch {
@@ -3310,7 +5976,7 @@ function handleEnv(args2) {
     filtered.slice(0, maxShow).forEach((key) => {
       const value = env[key] || "";
       const displayValue = value.length > 50 ? value.slice(0, 47) + "..." : value;
-      console.log(`  ${chalk3.hex("#E06C75")(key.padEnd(25))} ${theme.dim("=")} ${displayValue}`);
+      console.log(`  ${chalk5.hex("#E06C75")(key.padEnd(25))} ${theme.dim("=")} ${displayValue}`);
     });
     if (filtered.length > maxShow) {
       console.log(theme.dim(`  ... and ${filtered.length - maxShow} more`));
@@ -3339,22 +6005,22 @@ function handleIp() {
     if (localIps.length === 0) {
       console.log(`    ${theme.dim("(No network interfaces found)")}`);
     } else {
-      localIps.forEach((ip) => console.log(`    ${chalk3.hex("#98C379")(ip)}`));
+      localIps.forEach((ip) => console.log(`    ${chalk5.hex("#98C379")(ip)}`));
     }
     console.log("");
     console.log(theme.dim("  Public IP:"));
     try {
       let result;
       try {
-        result = execSync("curl -s ifconfig.me", { encoding: "utf-8", timeout: 5e3 }).trim();
+        result = execSync3("curl -s ifconfig.me", { encoding: "utf-8", timeout: 5e3 }).trim();
       } catch {
-        if (isWindows) {
-          result = execSync('powershell -command "(Invoke-WebRequest -Uri ifconfig.me -UseBasicParsing).Content"', { encoding: "utf-8", timeout: 5e3 }).trim();
+        if (isWindows2) {
+          result = execSync3('powershell -command "(Invoke-WebRequest -Uri ifconfig.me -UseBasicParsing).Content"', { encoding: "utf-8", timeout: 5e3 }).trim();
         } else {
           throw new Error("curl not available");
         }
       }
-      console.log(`    ${chalk3.hex("#61AFEF")(result)}`);
+      console.log(`    ${chalk5.hex("#61AFEF")(result)}`);
     } catch {
       console.log(`    ${theme.dim("(Could not fetch - requires curl or internet)")}`);
     }
@@ -3371,21 +6037,21 @@ function handleEpoch(args2) {
   if (!input || input === "now") {
     const now = /* @__PURE__ */ new Date();
     console.log(`  ${theme.dim("Current Time:")}`);
-    console.log(`    ${chalk3.hex("#98C379")(now.toISOString())}`);
-    console.log(`    ${chalk3.hex("#61AFEF")(Math.floor(now.getTime() / 1e3).toString())} ${theme.dim("(Unix seconds)")}`);
-    console.log(`    ${chalk3.hex("#E5C07B")(now.getTime().toString())} ${theme.dim("(Unix milliseconds)")}`);
+    console.log(`    ${chalk5.hex("#98C379")(now.toISOString())}`);
+    console.log(`    ${chalk5.hex("#61AFEF")(Math.floor(now.getTime() / 1e3).toString())} ${theme.dim("(Unix seconds)")}`);
+    console.log(`    ${chalk5.hex("#E5C07B")(now.getTime().toString())} ${theme.dim("(Unix milliseconds)")}`);
   } else if (/^\d{10,13}$/.test(input)) {
     const ms = input.length === 10 ? parseInt(input) * 1e3 : parseInt(input);
     const date = new Date(ms);
-    console.log(`  ${theme.dim("Epoch:")} ${chalk3.hex("#E5C07B")(input)}`);
-    console.log(`  ${theme.dim("Date:")}  ${chalk3.hex("#98C379")(date.toISOString())}`);
-    console.log(`         ${chalk3.hex("#98C379")(date.toLocaleString())}`);
+    console.log(`  ${theme.dim("Epoch:")} ${chalk5.hex("#E5C07B")(input)}`);
+    console.log(`  ${theme.dim("Date:")}  ${chalk5.hex("#98C379")(date.toISOString())}`);
+    console.log(`         ${chalk5.hex("#98C379")(date.toLocaleString())}`);
   } else {
     const date = new Date(input);
     if (!isNaN(date.getTime())) {
-      console.log(`  ${theme.dim("Date:")}  ${chalk3.hex("#98C379")(input)}`);
-      console.log(`  ${theme.dim("Unix:")}  ${chalk3.hex("#61AFEF")(Math.floor(date.getTime() / 1e3).toString())} ${theme.dim("(seconds)")}`);
-      console.log(`         ${chalk3.hex("#E5C07B")(date.getTime().toString())} ${theme.dim("(milliseconds)")}`);
+      console.log(`  ${theme.dim("Date:")}  ${chalk5.hex("#98C379")(input)}`);
+      console.log(`  ${theme.dim("Unix:")}  ${chalk5.hex("#61AFEF")(Math.floor(date.getTime() / 1e3).toString())} ${theme.dim("(seconds)")}`);
+      console.log(`         ${chalk5.hex("#E5C07B")(date.getTime().toString())} ${theme.dim("(milliseconds)")}`);
     } else {
       console.log(theme.error(`  Cannot parse: ${input}`));
       console.log(theme.dim('  Examples: epoch now, epoch 1703788800, epoch "2024-01-01"'));
@@ -3409,19 +6075,19 @@ async function handleHttp(args2) {
     return;
   }
   const fullUrl = url.startsWith("http") ? url : `https://${url}`;
-  console.log(`  ${symbols.rocket} ${theme.dim(method)} ${chalk3.hex("#61AFEF")(fullUrl)}`);
+  console.log(`  ${symbols.rocket} ${theme.dim(method)} ${chalk5.hex("#61AFEF")(fullUrl)}`);
   console.log("");
   try {
     let result;
     try {
       const curlCmd = method === "HEAD" ? `curl -sI "${fullUrl}"` : `curl -s -X ${method} "${fullUrl}"`;
-      result = execSync(curlCmd, { encoding: "utf-8", timeout: 1e4 });
+      result = execSync3(curlCmd, { encoding: "utf-8", timeout: 1e4 });
     } catch {
-      if (isWindows) {
+      if (isWindows2) {
         if (method === "HEAD") {
-          result = execSync(`powershell -command "(Invoke-WebRequest -Uri '${fullUrl}' -Method Head -UseBasicParsing).Headers | ConvertTo-Json"`, { encoding: "utf-8", timeout: 1e4 });
+          result = execSync3(`powershell -command "(Invoke-WebRequest -Uri '${fullUrl}' -Method Head -UseBasicParsing).Headers | ConvertTo-Json"`, { encoding: "utf-8", timeout: 1e4 });
         } else {
-          result = execSync(`powershell -command "(Invoke-WebRequest -Uri '${fullUrl}' -Method ${method} -UseBasicParsing).Content"`, { encoding: "utf-8", timeout: 1e4 });
+          result = execSync3(`powershell -command "(Invoke-WebRequest -Uri '${fullUrl}' -Method ${method} -UseBasicParsing).Content"`, { encoding: "utf-8", timeout: 1e4 });
         }
       } else {
         throw new Error("curl not available");
@@ -3459,22 +6125,22 @@ function handleDiff(args2) {
     console.log("");
     return;
   }
-  const path1 = resolve2(process.cwd(), file1);
-  const path2 = resolve2(process.cwd(), file2);
-  if (!existsSync4(path1)) {
+  const path1 = resolve5(process.cwd(), file1);
+  const path2 = resolve5(process.cwd(), file2);
+  if (!existsSync11(path1)) {
     console.log(theme.error(`  File not found: ${file1}`));
     console.log("");
     return;
   }
-  if (!existsSync4(path2)) {
+  if (!existsSync11(path2)) {
     console.log(theme.error(`  File not found: ${file2}`));
     console.log("");
     return;
   }
   try {
-    const content1 = readFileSync3(path1, "utf-8").split("\n");
-    const content2 = readFileSync3(path2, "utf-8").split("\n");
-    console.log(theme.primary(`  Comparing: ${basename(file1)} \u2194 ${basename(file2)}`));
+    const content1 = readFileSync9(path1, "utf-8").split("\n");
+    const content2 = readFileSync9(path2, "utf-8").split("\n");
+    console.log(theme.primary(`  Comparing: ${basename4(file1)} \u2194 ${basename4(file2)}`));
     console.log("");
     const maxLines = Math.max(content1.length, content2.length);
     let differences = 0;
@@ -3483,8 +6149,8 @@ function handleDiff(args2) {
       const line2 = content2[i] || "";
       if (line1 !== line2) {
         differences++;
-        console.log(chalk3.hex("#E06C75")(`  - ${(i + 1).toString().padStart(4)}: ${line1.slice(0, 70)}`));
-        console.log(chalk3.hex("#98C379")(`  + ${(i + 1).toString().padStart(4)}: ${line2.slice(0, 70)}`));
+        console.log(chalk5.hex("#E06C75")(`  - ${(i + 1).toString().padStart(4)}: ${line1.slice(0, 70)}`));
+        console.log(chalk5.hex("#98C379")(`  + ${(i + 1).toString().padStart(4)}: ${line2.slice(0, 70)}`));
         console.log("");
       }
     }
@@ -3501,18 +6167,18 @@ function handleDiff(args2) {
   }
   console.log("");
 }
-var aliasesFile = join3(homedir3(), ".zammy-aliases.json");
+var aliasesFile = join9(homedir5(), ".zammy-aliases.json");
 function loadAliases() {
   try {
-    if (existsSync4(aliasesFile)) {
-      return JSON.parse(readFileSync3(aliasesFile, "utf-8"));
+    if (existsSync11(aliasesFile)) {
+      return JSON.parse(readFileSync9(aliasesFile, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveAliases(aliases) {
-  writeFileSync3(aliasesFile, JSON.stringify(aliases, null, 2));
+  writeFileSync6(aliasesFile, JSON.stringify(aliases, null, 2));
 }
 function handleAlias(args2) {
   const parts = args2.trim().split(/\s+/);
@@ -3542,7 +6208,7 @@ function handleAlias(args2) {
       console.log(theme.dim(`  Running: ${aliases[name]}`));
       console.log("");
       try {
-        const result = execSync(aliases[name], { encoding: "utf-8", cwd: process.cwd(), timeout: 3e4 });
+        const result = execSync3(aliases[name], { encoding: "utf-8", cwd: process.cwd(), timeout: 3e4 });
         console.log(result);
       } catch (error) {
         const err = error;
@@ -3574,7 +6240,7 @@ function handleNotify(args2) {
   const message = args2.trim() || "Notification from Zammy CLI";
   console.log("");
   try {
-    if (isWindows) {
+    if (isWindows2) {
       const ps = `
         [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
         [Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null
@@ -3583,10 +6249,10 @@ function handleNotify(args2) {
         $notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("Zammy CLI")
         $notifier.Show([Windows.UI.Notifications.ToastNotification]::new($template))
       `;
-      execSync(`powershell -command "${ps.replace(/\n/g, " ")}"`, { stdio: "pipe", timeout: 5e3 });
+      execSync3(`powershell -command "${ps.replace(/\n/g, " ")}"`, { stdio: "pipe", timeout: 5e3 });
     } else {
-      const cmd = platform2() === "darwin" ? `osascript -e 'display notification "${message}" with title "Zammy CLI"'` : `notify-send "Zammy CLI" "${message}"`;
-      execSync(cmd, { stdio: "pipe", timeout: 3e3 });
+      const cmd = platform3() === "darwin" ? `osascript -e 'display notification "${message}" with title "Zammy CLI"'` : `notify-send "Zammy CLI" "${message}"`;
+      execSync3(cmd, { stdio: "pipe", timeout: 3e3 });
     }
     console.log(`  ${symbols.check} ${theme.success("Notification sent")}`);
   } catch {
@@ -3616,7 +6282,7 @@ function handleGrep(args2) {
   function searchFile(filePath) {
     if (results.length >= maxResults) return;
     try {
-      const content = readFileSync3(filePath, "utf-8");
+      const content = readFileSync9(filePath, "utf-8");
       const lines = content.split("\n");
       lines.forEach((line, index) => {
         if (results.length >= maxResults) return;
@@ -3634,11 +6300,11 @@ function handleGrep(args2) {
   function searchDir(dir, depth = 0) {
     if (depth > 4 || results.length >= maxResults) return;
     try {
-      const entries = readdirSync(dir, { withFileTypes: true });
+      const entries = readdirSync4(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (results.length >= maxResults) break;
         if (entry.name.startsWith(".") || ["node_modules", ".git", "dist", "build"].includes(entry.name)) continue;
-        const fullPath = resolve2(dir, entry.name);
+        const fullPath = resolve5(dir, entry.name);
         if (entry.isDirectory()) {
           searchDir(fullPath, depth + 1);
         } else {
@@ -3661,9 +6327,9 @@ function handleGrep(args2) {
     for (const result of results) {
       const highlightedContent = result.content.replace(
         regex,
-        (match) => chalk3.hex("#FF6B6B").bold(match)
+        (match) => chalk5.hex("#FF6B6B").bold(match)
       );
-      console.log(`  ${theme.dim(result.file)}:${chalk3.hex("#61AFEF")(result.line)}`);
+      console.log(`  ${theme.dim(result.file)}:${chalk5.hex("#61AFEF")(result.line)}`);
       console.log(`    ${highlightedContent}`);
       console.log("");
     }
@@ -3674,30 +6340,30 @@ function handleGrep(args2) {
   console.log("");
 }
 function handleWc(args2) {
-  const filePath = resolve2(process.cwd(), args2.trim());
+  const filePath = resolve5(process.cwd(), args2.trim());
   console.log("");
   if (!args2.trim()) {
     console.log(theme.error("  Usage: wc <file>"));
     console.log("");
     return;
   }
-  if (!existsSync4(filePath)) {
+  if (!existsSync11(filePath)) {
     console.log(theme.error(`  File not found: ${args2}`));
     console.log("");
     return;
   }
   try {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const lines = content.split("\n").length;
     const words = content.split(/\s+/).filter((w) => w.length > 0).length;
     const chars = content.length;
     const bytes = Buffer.byteLength(content, "utf-8");
-    console.log(theme.primary(`  \u{1F4CA} ${basename(args2)}`));
+    console.log(theme.primary(`  \u{1F4CA} ${basename4(args2)}`));
     console.log("");
-    console.log(`  ${chalk3.hex("#61AFEF")(lines.toLocaleString().padStart(8))} ${theme.dim("lines")}`);
-    console.log(`  ${chalk3.hex("#98C379")(words.toLocaleString().padStart(8))} ${theme.dim("words")}`);
-    console.log(`  ${chalk3.hex("#E5C07B")(chars.toLocaleString().padStart(8))} ${theme.dim("characters")}`);
-    console.log(`  ${chalk3.hex("#C678DD")(bytes.toLocaleString().padStart(8))} ${theme.dim("bytes")}`);
+    console.log(`  ${chalk5.hex("#61AFEF")(lines.toLocaleString().padStart(8))} ${theme.dim("lines")}`);
+    console.log(`  ${chalk5.hex("#98C379")(words.toLocaleString().padStart(8))} ${theme.dim("words")}`);
+    console.log(`  ${chalk5.hex("#E5C07B")(chars.toLocaleString().padStart(8))} ${theme.dim("characters")}`);
+    console.log(`  ${chalk5.hex("#C678DD")(bytes.toLocaleString().padStart(8))} ${theme.dim("bytes")}`);
   } catch {
     console.log(theme.error("  Failed to read file"));
   }
@@ -3717,19 +6383,19 @@ function handleHead(args2) {
     console.log("");
     return;
   }
-  const fullPath = resolve2(process.cwd(), filePath);
-  if (!existsSync4(fullPath)) {
+  const fullPath = resolve5(process.cwd(), filePath);
+  if (!existsSync11(fullPath)) {
     console.log(theme.error(`  File not found: ${filePath}`));
     console.log("");
     return;
   }
   try {
-    const content = readFileSync3(fullPath, "utf-8");
+    const content = readFileSync9(fullPath, "utf-8");
     const fileLines = content.split("\n").slice(0, lines);
-    console.log(theme.dim(`  First ${lines} lines of ${basename(filePath)}:`));
+    console.log(theme.dim(`  First ${lines} lines of ${basename4(filePath)}:`));
     console.log("");
     fileLines.forEach((line, i) => {
-      console.log(`  ${chalk3.dim((i + 1).toString().padStart(4))} ${line}`);
+      console.log(`  ${chalk5.dim((i + 1).toString().padStart(4))} ${line}`);
     });
   } catch {
     console.log(theme.error("  Failed to read file"));
@@ -3761,8 +6427,9 @@ async function executeShellCommand(command) {
     return;
   }
   if (cmd === "clear" || cmd === "cls") {
-    console.clear();
-    await displayBanner();
+    process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+    const isSimple = process.argv.includes("--simple") || !process.stdout.isTTY;
+    await displayBanner(isSimple);
     return;
   }
   if (cmd === "bookmark" || cmd === "bm") {
@@ -3875,6 +6542,29 @@ async function parseAndExecute(input) {
     return;
   }
   if (!trimmed.startsWith("/")) {
+    const detectedMood = getMoodFromText(trimmed);
+    if (detectedMood) {
+      console.log("");
+      const responses = {
+        love: ["Aww, you're sweet!", "Right back at ya!", "*happy wobble*"],
+        excited: ["Yay! Let's gooo!", "Woohoo!", "*bounces excitedly*"],
+        sleepy: ["*yawns* Same...", "Maybe take a break?", "zzZ..."],
+        sad: ["Aww, it's okay!", "I'm here for you!", "*comforting wobble*"],
+        angry: ["*hides nervously*", "Let's fix that!", "Deep breaths..."],
+        thinking: ["Hmm indeed...", "Let me think too...", "*ponders*"]
+      };
+      const moodResponses = responses[detectedMood] || ["*wobbles*"];
+      const response = moodResponses[Math.floor(Math.random() * moodResponses.length)];
+      const isSimpleInput = trimmed.length < 20 && !/[{}\[\]();=<>]/.test(trimmed);
+      if ((detectedMood === "love" || detectedMood === "excited") && isSimpleInput && Math.random() < 0.5) {
+        showMascot(detectedMood);
+        console.log(`  ${theme.secondary(response)}`);
+      } else {
+        react(detectedMood, theme.secondary(response));
+      }
+      console.log("");
+      return;
+    }
     console.log("");
     console.log(`  ${symbols.info} ${theme.dim("Commands start with")} ${theme.primary("/")} ${theme.dim("\u2022 Shell commands start with")} ${theme.primary("!")}`);
     console.log(`  ${theme.dim("   Type")} ${theme.primary("/help")} ${theme.dim("for available commands")}`);
@@ -3894,24 +6584,110 @@ async function parseAndExecute(input) {
   }
   try {
     await command.execute(args2);
+    if (Math.random() < 0.15) {
+      const successMoods = ["happy", "excited", "wink"];
+      const mood = successMoods[Math.floor(Math.random() * successMoods.length)];
+      react(mood);
+    }
   } catch (error) {
     console.log("");
-    console.log(`  ${symbols.cross} ${theme.error("Error:")} ${theme.dim(String(error))}`);
+    react("sad", theme.error(`Error: ${String(error)}`));
     console.log("");
   }
 }
 
 // src/index.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join as join4 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync10 } from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname5, join as join10 } from "path";
+import chalk6 from "chalk";
+var SLIME_COLOR = "#9B59B6";
+var EYE_COLOR = "#1A1A2E";
+var MIN_WIDTH_FOR_IDLE = 40;
+var MIN_WIDTH_FOR_MENU = 50;
+var miniSlimeFrames = [
+  // Open eyes
+  chalk6.hex(SLIME_COLOR)("(") + chalk6.hex(EYE_COLOR)("\u25CF") + chalk6.hex(SLIME_COLOR)("\u1D17") + chalk6.hex(EYE_COLOR)("\u25CF") + chalk6.hex(SLIME_COLOR)(")"),
+  // Blink (closed eyes)
+  chalk6.hex(SLIME_COLOR)("(") + chalk6.hex(EYE_COLOR)("\u2500") + chalk6.hex(SLIME_COLOR)("\u1D17") + chalk6.hex(EYE_COLOR)("\u2500") + chalk6.hex(SLIME_COLOR)(")")
+];
+var idleAnimationInterval = null;
+var isUserTyping = false;
+var lastActivityTime = Date.now();
+var lastRenderedFrame = -1;
+var slimeVisible = false;
+var lastTermWidth = process.stdout.columns || 80;
+var IDLE_DELAY = 3e3;
+var FRAME_INTERVAL = 2e3;
+var animationSequence = [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0];
+var sequenceIndex = 0;
+function getAnimatedSlime() {
+  const frameIndex = animationSequence[sequenceIndex % animationSequence.length];
+  return { frame: miniSlimeFrames[frameIndex], index: frameIndex };
+}
+function updateIdleAnimation(rl) {
+  const termWidth = process.stdout.columns || 80;
+  if (isUserTyping || menu.visible || termWidth < MIN_WIDTH_FOR_IDLE) {
+    if (slimeVisible) {
+      clearIdleSlime(rl);
+    }
+    return;
+  }
+  const now = Date.now();
+  if (now - lastActivityTime < IDLE_DELAY) return;
+  const currentLine = rl.line || "";
+  if (currentLine.length !== 0) return;
+  sequenceIndex++;
+  const { frame: slime, index: frameIndex } = getAnimatedSlime();
+  if (frameIndex === lastRenderedFrame && slimeVisible) return;
+  lastRenderedFrame = frameIndex;
+  slimeVisible = true;
+  const promptLen = getPromptLength();
+  const slimePos = Math.max(promptLen + 3, termWidth - 12);
+  process.stdout.write(
+    `\x1B[?25l\x1B[${slimePos}G\x1B[K` + // Clear to end of line
+    slime + // Draw slime
+    `\x1B[${promptLen + 1}G\x1B[?25h`
+    // Show cursor
+  );
+}
+function startIdleAnimation(rl) {
+  if (idleAnimationInterval) return;
+  idleAnimationInterval = setInterval(() => {
+    updateIdleAnimation(rl);
+  }, FRAME_INTERVAL);
+}
+function stopIdleAnimation() {
+  if (idleAnimationInterval) {
+    clearInterval(idleAnimationInterval);
+    idleAnimationInterval = null;
+  }
+}
+function clearIdleSlime(rl) {
+  if (!slimeVisible) return;
+  slimeVisible = false;
+  lastRenderedFrame = -1;
+  const termWidth = process.stdout.columns || 80;
+  const slimePos = termWidth - 12;
+  const promptLen = getPromptLength();
+  const currentLine = rl ? rl.line || "" : "";
+  const cursorPos = promptLen + currentLine.length + 1;
+  process.stdout.write(
+    `\x1B[?25l\x1B[${slimePos}G\x1B[K\x1B[${cursorPos}G\x1B[?25h`
+    // Show cursor
+  );
+}
+function setIdle() {
+  isUserTyping = false;
+  lastActivityTime = Date.now();
+}
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
   try {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const pkgPath = join4(__dirname, "..", "package.json");
-    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    const __filename = fileURLToPath4(import.meta.url);
+    const __dirname = dirname5(__filename);
+    const pkgPath = join10(__dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     console.log(`zammy v${pkg.version}`);
   } catch {
     console.log("zammy v1.0.0");
@@ -3920,14 +6696,15 @@ if (args.includes("--version") || args.includes("-v")) {
 }
 if (args.includes("--help") || args.includes("-h")) {
   console.log(`
-zammy - Your slice-of-life terminal companion
+zammy - A feature-packed CLI with utilities, dev tools, and a bit of fun
 
 Usage: zammy [options]
 
 Options:
   -v, --version    Show version number
   -h, --help       Show this help message
-  --simple         Force simple mode (no interactive features)
+  --simple         Force simple mode (no animations)
+  --no-menu        Disable interactive command menu
 
 Commands:
   Start zammy and type / to see all available commands
@@ -3942,6 +6719,7 @@ Examples:
 }
 var isTTY = process.stdin.isTTY && process.stdout.isTTY;
 var isSimpleMode = process.argv.includes("--simple") || !isTTY;
+var noMenu = process.argv.includes("--no-menu");
 var IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp"];
 var menu = {
   visible: false,
@@ -4060,6 +6838,11 @@ function hideMenu(currentLine = "") {
   menu.renderedLines = 0;
 }
 function showMenu(filter, prefix, currentLine) {
+  const termWidth = process.stdout.columns || 80;
+  if (termWidth < MIN_WIDTH_FOR_MENU) {
+    if (menu.visible) hideMenu(currentLine);
+    return;
+  }
   const allItems = prefix === "/" ? getFilteredCommands(filter) : getFilteredShellCommands(filter);
   if (allItems.length === 0) {
     if (menu.visible) hideMenu(currentLine);
@@ -4125,7 +6908,7 @@ function completer(line) {
       const afterCommand = line.slice("/asciiart ".length);
       const searchTerm = afterCommand.startsWith("@") ? afterCommand.slice(1) : afterCommand;
       try {
-        const files = readdirSync2(process.cwd());
+        const files = readdirSync5(process.cwd());
         const imageFiles = files.filter((f) => {
           const ext = f.toLowerCase().slice(f.lastIndexOf("."));
           return IMAGE_EXTENSIONS.includes(ext);
@@ -4154,8 +6937,9 @@ async function main() {
     console.log(theme.dim("Note: Running in simple mode (no TTY detected). Use Tab for autocomplete."));
     console.log(theme.dim("For full features, run in a proper terminal or use: zammy --simple\n"));
   }
-  await displayBanner();
-  const rl = readline.createInterface({
+  await displayBanner(isSimpleMode);
+  await initPluginLoader();
+  const rl = readline4.createInterface({
     input: process.stdin,
     output: process.stdout,
     terminal: isTTY,
@@ -4163,8 +6947,29 @@ async function main() {
   });
   let prevLine = "";
   if (isTTY && !isSimpleMode) {
+    startIdleAnimation(rl);
+  }
+  if (isTTY) {
+    process.stdout.on("resize", () => {
+      const currentLine = rl.line || "";
+      const newWidth = process.stdout.columns || 80;
+      if (menu.visible) {
+        hideMenu(currentLine);
+      }
+      if (slimeVisible) {
+        clearIdleSlime(rl);
+      }
+      process.stdout.write("\r" + getPrompt() + currentLine);
+      lastTermWidth = newWidth;
+    });
+  }
+  if (isTTY && !noMenu) {
     process.stdin.on("keypress", (_char, key) => {
       if (!key) return;
+      if (!isSimpleMode) {
+        isUserTyping = true;
+        lastActivityTime = Date.now();
+      }
       const currentLine = rl.line || "";
       if (menu.visible) {
         if (key.name === "up" || key.name === "down") {
@@ -4202,6 +7007,7 @@ async function main() {
     const line = rl.line || "";
     if (now - lastCtrlC < 500) {
       hideMenu(line);
+      stopIdleAnimation();
       console.log("\n" + theme.secondary("Goodbye! See you next time.") + "\n");
       process.exit(0);
     } else {
@@ -4216,6 +7022,7 @@ async function main() {
     hideMenu(input);
     prevLine = "";
     await parseAndExecute(input);
+    if (!isSimpleMode) setIdle();
     rl.prompt();
   });
   rl.prompt();