zammy 1.2.1 → 1.3.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/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";
@@ -181,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 = [];
@@ -534,7 +543,7 @@ 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((resolve3) => {
+  return new Promise((resolve6) => {
     const termWidth = process.stdout.columns || 80;
     figlet("ZAMMY", {
       font: "ANSI Shadow",
@@ -548,7 +557,7 @@ async function displayBanner(simple = false) {
         console.log(theme.secondary(`  "${greeting}"`));
         console.log(theme.dim("  Type /help for commands"));
         console.log("");
-        resolve3();
+        resolve6();
         return;
       }
       let figletLines = [];
@@ -581,7 +590,7 @@ async function displayBanner(simple = false) {
         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();
         return;
       }
       const figletWidth = 50;
@@ -611,7 +620,7 @@ async function displayBanner(simple = false) {
       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();
     });
   });
 }
@@ -624,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);
@@ -632,6 +651,20 @@ 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 = {
@@ -639,7 +672,8 @@ var categories = {
   "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",
@@ -692,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)));
@@ -1142,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) {
@@ -1150,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];
@@ -1468,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" },
@@ -1536,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 = [];
@@ -1556,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")}`);
@@ -2106,8 +2496,8 @@ registerCommand({
 
 // src/commands/creative/asciiart.ts
 import Jimp from "jimp";
-import { existsSync as existsSync3 } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve2 } from "path";
 var CHAR_RAMPS = {
   // Standard - 10 levels, balanced
   standard: " .:-=+*#%@",
@@ -2212,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;
     }
@@ -2865,53 +3255,1880 @@ registerCommand({
   }
 });
 
-// src/commands/info/weather.ts
+// 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: "weather",
-  description: "Get current weather for a city",
-  usage: "/weather <city>",
+  name: "json",
+  description: "JSON tools (validate, format, query)",
+  usage: "/json <action> <input>\n\n  Actions: validate, format, minify, query, stats",
   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;
+    const action = args2[0]?.toLowerCase();
+    const input = args2.slice(1).join(" ");
+    if (!action) {
       console.log("");
-      console.log(theme.highlight(`${cityName}, ${country}`));
+      console.log(`  ${symbols.sparkle} ${theme.gradient("JSON TOOLS")}`);
       console.log("");
-      console.log(`  ${theme.primary(desc)}`);
-      console.log(`  Temperature: ${theme.warning(temp + "\xB0C")} (feels like ${feelsLike}\xB0C)`);
-      console.log(`  Humidity: ${humidity}%`);
+      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}`));
+    } 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/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;
+  };
+}
+
+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.check} ${theme.success("Plugin created successfully!")}`);
+    console.log("");
+    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("");
+    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/commands/plugin/index.ts
+registerCommand({
+  name: "plugin",
+  description: "Manage zammy plugins",
+  usage: "/plugin <list|install|remove|create> [args]",
+  async execute(args2) {
+    const subcommand = args2[0]?.toLowerCase();
+    if (!subcommand || subcommand === "help") {
+      console.log("");
+      console.log(`  ${symbols.gear} ${theme.gradient("PLUGIN MANAGER")}`);
+      console.log("");
+      console.log(`  ${theme.primary("Usage:")} /plugin <command> [args]`);
+      console.log("");
+      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("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("");
+      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 { 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 isWindows = platform2() === "win32";
+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);
@@ -2963,21 +5180,21 @@ 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)) {
+  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(`${miniSlime.sad} ${theme.error(`Not a directory: ${targetPath}`)}`);
       return;
@@ -2992,13 +5209,13 @@ function handlePwd() {
   console.log(theme.primary(process.cwd()));
 }
 function handleCat(args2) {
-  const filePath = resolve2(process.cwd(), args2.trim());
-  if (!existsSync4(filePath)) {
+  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));
@@ -3097,13 +5314,13 @@ function handleLs(args2) {
   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}`));
@@ -3119,14 +5336,14 @@ function handleLs(args2) {
       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 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 += chalk5.dim(date.padEnd(13)) + size + "  ";
@@ -3148,19 +5365,19 @@ 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, b3) => {
+      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);
@@ -3173,7 +5390,7 @@ function handleTree(args2, maxDepth = 3) {
         if (entry.isDirectory()) {
           dirCount++;
           console.log(theme.dim(prefix + connector) + iconInfo.icon + " " + chalk5.hex(iconInfo.color).bold(entry.name + "/"));
-          printTree(resolve2(dir, entry.name), prefix + (isLast ? "    " : "\u2502   "), depth + 1);
+          printTree(resolve5(dir, entry.name), prefix + (isLast ? "    " : "\u2502   "), depth + 1);
         } else {
           fileCount++;
           console.log(theme.dim(prefix + connector) + iconInfo.icon + " " + chalk5.hex(iconInfo.color)(entry.name));
@@ -3187,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+/);
@@ -3254,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]}`);
         }
@@ -3271,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)) {
@@ -3298,7 +5515,7 @@ 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)}${chalk5.hex(iconInfo.color)(fileName)}${result.isDir ? "/" : ""}`);
     }
@@ -3310,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;
   }
@@ -3319,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 {
@@ -3331,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 {
@@ -3348,7 +5565,7 @@ function handleDu(args2) {
   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;
@@ -3377,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 {
         }
       }
@@ -3408,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("");
@@ -3418,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();
+        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 {
@@ -3458,7 +5675,7 @@ 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) => {
@@ -3470,7 +5687,7 @@ function handleGit(args2) {
       }
       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) => {
@@ -3481,7 +5698,7 @@ function handleGit(args2) {
       }
       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) => {
@@ -3494,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) {
@@ -3503,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";
@@ -3533,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 {
@@ -3548,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);
@@ -3559,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 {
@@ -3592,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);
@@ -3646,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"));
@@ -3669,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 {
@@ -3683,7 +5900,7 @@ 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));
@@ -3706,7 +5923,7 @@ function handleServe(args2) {
   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"
@@ -3721,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)));
@@ -3736,7 +5953,7 @@ function handlePs() {
         }
       });
     } 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 {
@@ -3795,10 +6012,10 @@ function handleIp() {
     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");
         }
@@ -3864,13 +6081,13 @@ async function handleHttp(args2) {
     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");
@@ -3908,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;
@@ -3950,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+/);
@@ -3991,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;
@@ -4023,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
@@ -4032,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 {
@@ -4065,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;
@@ -4083,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 {
@@ -4123,25 +6340,25 @@ 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(`  ${chalk5.hex("#61AFEF")(lines.toLocaleString().padStart(8))} ${theme.dim("lines")}`);
     console.log(`  ${chalk5.hex("#98C379")(words.toLocaleString().padStart(8))} ${theme.dim("words")}`);
@@ -4166,16 +6383,16 @@ 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(`  ${chalk5.dim((i + 1).toString().padStart(4))} ${line}`);
@@ -4380,9 +6597,9 @@ async function parseAndExecute(input) {
 }
 
 // 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";
@@ -4467,10 +6684,10 @@ function setIdle() {
 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");
@@ -4691,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);
@@ -4721,7 +6938,8 @@ async function main() {
     console.log(theme.dim("For full features, run in a proper terminal or use: zammy --simple\n"));
   }
   await displayBanner(isSimpleMode);
-  const rl = readline.createInterface({
+  await initPluginLoader();
+  const rl = readline4.createInterface({
     input: process.stdin,
     output: process.stdout,
     terminal: isTTY,