evophp 1.3.0 → 1.3.2

package/README.md

@@ -16,6 +16,7 @@ EvoPHP CLI is a command-line interface designed to simplify the development and
   * [Plugin/Theme Uninstallation](#plugintheme-uninstallation)
   * [Dependency Management](#dependency-management)
   * [Entry Management](#entry-management)
+* [Plugin & Theme Dependencies](#plugin--theme-dependencies)
 * [Authentication & PAT Storage](#authentication--pat-storage)
 * [Further Documentation](#further-documentation)
 
@@ -104,6 +105,8 @@ evophp i theme <name>
   evophp i theme johndoe/EvoTheme
   ```
 
+* **Automatic dependency installation**: If the plugin or theme includes a `dependencies.json` file, EvoPHP will automatically install all listed JS/PHP packages and any dependent EvoPHP plugins or themes. See [Plugin & Theme Dependencies](#plugin--theme-dependencies).
+
 ---
 
 ### Plugin/Theme Uninstallation
@@ -116,6 +119,7 @@ evophp u theme <name>
 ```
 
 * Removes the installed plugin or theme from the project.
+* Also removes any EvoPHP plugin/theme dependencies that were installed alongside it — **unless** they are still required by another installed plugin or theme, in which case they are retained.
 
 * Examples:
 
@@ -133,7 +137,7 @@ evophp install-dependencies <plugin-name>
 evophp d <plugin-name>
 ```
 
-* Adds or installs plugin dependencies.
+* Adds or installs plugin dependencies — npm packages, Composer packages, or other EvoPHP plugins/themes.
 
 #### Production (npm):
 
@@ -153,6 +157,25 @@ evophp d MyPlugin --dev
 evophp d MyPlugin --composer
 ```
 
+#### EvoPHP Plugin dependency:
+
+```bash
+evophp d MyPlugin --evoplugin
+```
+
+* Prompts for one or more `author/name` (or plain `name`) EvoPHP plugins to add as dependencies.
+* Clones and installs each listed plugin into the project.
+* Records them under the `"plugin"` key in `MyPlugin`'s `dependencies.json`.
+* A GitHub token is only required when a dependency is provided without an `author/` prefix.
+
+#### EvoPHP Theme dependency:
+
+```bash
+evophp d MyPlugin --evotheme
+```
+
+* Same as `--evoplugin` but for themes — clones, installs, and records under the `"theme"` key in `dependencies.json`.
+
 ---
 
 ### Entry Management
@@ -179,6 +202,68 @@ evophp e <plugin> <entry>
 evophp entry MyPlugin Dashboard
 ```
 
+### Patch PHP & JS Dependencies
+
+```bash
+evophp patch --upgrade
+evophp p
+```
+
+This is used to update core libraries of EvoPhp.
+
+---
+
+## Plugin & Theme Dependencies
+
+EvoPHP supports a `dependencies.json` file at the root of any plugin or theme. This file declares all dependencies that should be automatically resolved during installation.
+
+### Structure
+
+```json
+{
+  "prod": "qrcode.vue vue3-qrcode-reader jspdf @fullcalendar/core @fullcalendar/vue3",
+  "dev": "",
+  "plugin": "kinsokafor/Invoice kinsokafor/GooglePack",
+  "theme": "kinsokafor/BSTTheme"
+}
+```
+
+| Key | Type | Description |
+|---|---|---|
+| `prod` | string | Space-separated npm packages to install as production dependencies |
+| `dev` | string | Space-separated npm packages to install as dev dependencies |
+| `plugin` | string | Space-separated `author/name` EvoPHP plugins this plugin/theme depends on |
+| `theme` | string | Space-separated `author/name` EvoPHP themes this plugin/theme depends on |
+
+### Automatic Installation
+
+When you run `evophp install`, EvoPHP will:
+
+1. Clone the plugin or theme from GitHub.
+2. Read its `dependencies.json` (if present).
+3. Install all listed npm (`prod`/`dev`) and Composer (`prod`) packages.
+4. Recursively install any EvoPHP plugins or themes listed under `"plugin"` and `"theme"` — each of which may declare their own `dependencies.json`, resolved the same way.
+
+### Automatic Uninstallation
+
+When you run `evophp uninstall`, EvoPHP will:
+
+1. Remove the target plugin or theme.
+2. Check each of its EvoPHP plugin/theme dependencies.
+3. Remove a dependency only if **no other installed plugin or theme** still requires it. If another plugin depends on it, it is retained and a notice is shown.
+
+Example:
+
+```
+PluginA depends on → Invoice, GooglePack
+PluginB depends on → Invoice
+
+evophp uninstall plugin PluginA
+  ✔ PluginA removed
+  ⚠ Invoice retained (still required by PluginB)
+  ✔ GooglePack removed
+```
+
 ---
 
 ## Authentication & PAT Storage
@@ -198,4 +283,4 @@ When using a command with just `<name>` (e.g. `evophp new plugin MyPlugin`), Evo
 ## Further Documentation
 
 More advanced use cases, templates, and configuration details coming soon at:  
-📘 [Official EvoPHP Documentation](#)
+📘 [Official EvoPHP Documentation](#)

package/bin/evophp.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const yargs = require("yargs");
 const { hideBin } = require("yargs/helpers");

package/commands/dependencies.js

@@ -2,38 +2,217 @@ const fs = require("fs");
 const path = require("path");
 const { execSync } = require("child_process");
 const { readLineAsync } = require("../utils/helpers");
+const { getUserData } = require("../utils/github");
+const { cloneRepo } = require("../utils/git");
+const { installDependencies, extractDependencies } = require("../utils/dependencies");
 const log = require("../utils/logger");
+require("dotenv").config({ path: "./.env.development" });
+
+/**
+ * Installs a single evophp plugin or theme and records it in the
+ * parent plugin's dependencies.json under the appropriate key.
+ *
+ * @param {'plugin'|'theme'} depType
+ * @param {string} dep          - "author/name" or plain "name"
+ * @param {string} gitHubToken
+ * @param {object} dependencies - the in-memory dependencies object to mutate
+ */
+async function installEvoDep(depType, dep, gitHubToken, dependencies) {
+  let author, depName;
+
+  if (dep.includes("/")) {
+    [author, depName] = dep.split("/");
+  } else {
+    if (!gitHubToken) {
+      log.error(`A GitHub token is required to install "${dep}" without an author prefix.`);
+      process.exit(1);
+    }
+    const { getUserData } = require("../utils/github");
+    const userData = await getUserData(gitHubToken);
+    author = userData.login;
+    depName = dep;
+  }
+
+  const paths = depType === "plugin"
+    ? [path.join("Public", "Modules", depName), path.join("EvoJsDev", "Modules", depName)]
+    : [path.join("Public", "Themes", depName)];
+
+  if (paths.every(p => fs.existsSync(p))) {
+    log.warn(`${depType} "${depName}" is already installed, skipping clone.`);
+  } else {
+    log.info(`Installing ${depType} "${depName}" from ${author}...`);
+
+    if (depType === "plugin") {
+      await cloneRepo(`${author}/${depName}`, null, paths[0]);
+      await cloneRepo(`${author}/${depName}.js`, null, paths[1]);
+      await installDependencies(extractDependencies(paths[1], "js"), "js");
+      await installDependencies(extractDependencies(paths[0], "php"), "php");
+      await execSync(`evophp d ${author}/${depName} --sync`, { stdio: "inherit" });
+    } else {
+      await cloneRepo(`${author}/${depName}`, null, paths[0]);
+    }
+
+    log.success(`${depType} "${depName}" installed.`);
+  }
+
+  // Record as "author/name" in dependencies.json, deduplicated
+  const key = depType; // "plugin" or "theme"
+  const existing = (dependencies[key] || "")
+    .split(" ")
+    .map(d => d.trim())
+    .filter(Boolean);
+
+  const fullRef = `${author}/${depName}`;
+  if (!existing.some(d => d === fullRef || d.split("/").pop() === depName)) {
+    existing.push(fullRef);
+  }
+  dependencies[key] = existing.join(" ");
+}
 
 module.exports = {
-  command: "install-dependencies <plugin> [--dev|--composer]",
+  command: "install-dependencies <plugin> [--dev|--composer|--evoplugin|--evotheme|--sync]",
   aliases: ["d"],
   describe: "Add and install plugin or theme dependencies",
 
   builder: yargs =>
     yargs
       .positional("plugin", { describe: "Plugin or theme name", type: "string" })
-      .option("dev", { describe: "Install as dev dependency (JS)", type: "boolean" })
-      .option("composer", { describe: "Use composer for PHP", type: "boolean" }),
+      .option("dev",       { describe: "Install as dev dependency (JS)",                              type: "boolean" })
+      .option("composer",  { describe: "Use composer for PHP",                                        type: "boolean" })
+      .option("evoplugin", { describe: "Install an evophp plugin dependency",                         type: "boolean" })
+      .option("evotheme",  { describe: "Install an evophp theme dependency",                          type: "boolean" })
+      .option("sync",      { describe: "Install any missing evophp plugins/themes in dependencies.json", type: "boolean" }),
 
-  handler: async ({ plugin, dev, composer }) => {
+  handler: async ({ plugin, dev, composer, evoplugin, evotheme, sync }) => {
     try {
+      const isEvo  = !!(evoplugin || evotheme);
+      const isPHP  = !!composer;
       const depType = dev ? "dev" : "prod";
 
-      const isPHP = !!composer;
+      // ── sync: install any missing evophp plugins/themes from dependencies.json ──
+      if (sync) {
+        const evoDepsDir = path.join("EvoJsDev", "Modules", plugin);
+
+        if (!fs.existsSync(evoDepsDir)) {
+          log.error(`Plugin not found at ${evoDepsDir}`);
+          process.exit(1);
+        }
+
+        const dependenciesFile = path.join(evoDepsDir, "dependencies.json");
+        if (!fs.existsSync(dependenciesFile)) {
+          log.warn(`No dependencies.json found for "${plugin}".`);
+          return;
+        }
+
+        const dependencies = JSON.parse(fs.readFileSync(dependenciesFile, "utf-8"));
+
+        const pluginDeps = (dependencies.plugin || "").split(" ").map(d => d.trim()).filter(Boolean);
+        const themeDeps  = (dependencies.theme  || "").split(" ").map(d => d.trim()).filter(Boolean);
+
+        if (pluginDeps.length === 0 && themeDeps.length === 0) {
+          log.info("No evophp plugin or theme dependencies listed.");
+          return;
+        }
+
+        // Collect only the missing ones
+        const missingPlugins = pluginDeps.filter(dep => {
+          const depName = dep.includes("/") ? dep.split("/").pop() : dep;
+          return !fs.existsSync(path.join("Public", "Modules", depName)) ||
+                 !fs.existsSync(path.join("EvoJsDev", "Modules", depName));
+        });
+
+        const missingThemes = themeDeps.filter(dep => {
+          const depName = dep.includes("/") ? dep.split("/").pop() : dep;
+          return !fs.existsSync(path.join("Public", "Themes", depName));
+        });
+
+        if (missingPlugins.length === 0 && missingThemes.length === 0) {
+          log.success("All evophp dependencies are already installed.");
+          return;
+        }
+
+        log.info(`Missing plugins : ${missingPlugins.join(", ") || "none"}`);
+        log.info(`Missing themes  : ${missingThemes.join(", ")  || "none"}`);
+
+        // Resolve a token only if needed
+        let gitHubToken = process.env.GITHUB_TOKEN;
+        const needsToken = [...missingPlugins, ...missingThemes].some(d => !d.includes("/"));
+        if (needsToken && !gitHubToken) {
+          gitHubToken = await readLineAsync("Enter your GitHub Personal Access Token: ");
+          const { saveToEnv } = require("../utils/helpers");
+          saveToEnv("GITHUB_TOKEN", gitHubToken);
+          log.success("GitHub token saved to .env.development");
+        }
+
+        for (const dep of missingPlugins) {
+          await installEvoDep("plugin", dep, gitHubToken, dependencies);
+        }
+        for (const dep of missingThemes) {
+          await installEvoDep("theme", dep, gitHubToken, dependencies);
+        }
+
+        log.success(`Sync complete for "${plugin}".`);
+        return;
+      }
+
+      // For JS/PHP deps the source of truth lives in EvoJsDev; for PHP-only in Public
       const baseDir = isPHP
         ? path.join("Public", "Modules", plugin)
         : path.join("EvoJsDev", "Modules", plugin);
 
-      if (!fs.existsSync(baseDir)) {
-        log.error(`Plugin not found at ${baseDir}`);
+      // evophp deps are recorded in the JS side of the plugin
+      const evoDepsDir = path.join("EvoJsDev", "Modules", plugin);
+
+      const targetDir = isEvo ? evoDepsDir : baseDir;
+
+      if (!fs.existsSync(targetDir)) {
+        log.error(`Plugin not found at ${targetDir}`);
         process.exit(1);
       }
 
-      const dependenciesFile = path.join(baseDir, "dependencies.json");
+      const dependenciesFile = path.join(targetDir, "dependencies.json");
       let dependencies = fs.existsSync(dependenciesFile)
         ? JSON.parse(fs.readFileSync(dependenciesFile, "utf-8"))
         : {};
 
+      // ── evophp plugin / theme dependencies ────────────────────────────────
+      if (isEvo) {
+        const evoDepType = evoplugin ? "plugin" : "theme";
+
+        log.info(`Existing evophp ${evoDepType} dependencies:`);
+        log.info(dependencies[evoDepType] || "None");
+
+        const input = await readLineAsync(
+          `Enter evophp ${evoDepType}(s) to add as dependencies (space-separated, author/name or name): `
+        );
+        const newDeps = input.split(" ").map(d => d.trim()).filter(Boolean);
+
+        if (newDeps.length === 0) {
+          log.warn("No dependencies provided.");
+          return;
+        }
+
+        let gitHubToken = process.env.GITHUB_TOKEN;
+        // Only fetch a token if any dep is missing the author prefix
+        if (newDeps.some(d => !d.includes("/"))) {
+          if (!gitHubToken) {
+            gitHubToken = await readLineAsync("Enter your GitHub Personal Access Token: ");
+            const { saveToEnv } = require("../utils/helpers");
+            saveToEnv("GITHUB_TOKEN", gitHubToken);
+            log.success("GitHub token saved to .env.development");
+          }
+        }
+
+        for (const dep of newDeps) {
+          await installEvoDep(evoDepType, dep, gitHubToken, dependencies);
+        }
+
+        fs.writeFileSync(dependenciesFile, JSON.stringify(dependencies, null, 2));
+        log.success("Updated dependencies.json with new evophp dependencies.");
+        return;
+      }
+
+      // ── JS / PHP (npm / composer) dependencies ────────────────────────────
       log.info(`Existing ${isPHP ? "PHP" : "JS"} dependencies:`);
       log.info("Production:", dependencies.prod || "None");
       if (!isPHP) log.info("Development:", dependencies.dev || "None");
@@ -64,7 +243,6 @@ module.exports = {
       fs.writeFileSync(dependenciesFile, JSON.stringify(dependencies, null, 2));
       log.success("Updated dependencies.json");
 
-      // Install
       const installCmd = isPHP
         ? `composer require ${newDeps.join(" ")}`
         : `npm install ${newDeps.join(" ")} ${dev ? "--save-dev" : "--save"}`;
@@ -77,4 +255,4 @@ module.exports = {
       process.exit(1);
     }
   }
-};
+};

package/commands/init.js

@@ -3,6 +3,7 @@ const path = require("path");
 const { execSync } = require("child_process");
 const { readLineAsync } = require("../utils/helpers");
 const log = require("../utils/logger");
+// const { editFile } = require("../utils/edit");
 
 module.exports = {
   command: "init [name]",

package/commands/install.js

@@ -4,10 +4,102 @@ const { execSync } = require('child_process');
 const { readLineAsync, mergeConfig, saveToEnv } = require('../utils/helpers');
 const { getUserData } = require('../utils/github');
 const { cloneRepo } = require('../utils/git');
-const { installDependencies } = require('../utils/dependencies');
+const { installDependencies, extractDependencies, mergeDependencies } = require('../utils/dependencies');
 const log = require('../utils/logger');
 require("dotenv").config({ path: "./.env.development" });
 
+let jsDep = {};
+let phpDep = {};
+let configFiles = [];
+/**
+ * Core install logic for a single plugin or theme.
+ * Extracted so it can be called recursively for evophp dependencies.
+ *
+ * @param {'plugin'|'theme'} type
+ * @param {string} author
+ * @param {string} pluginName
+ * @param {string} gitHubToken
+ * @param {Set<string>} installed - tracks already-installed entries to avoid infinite loops
+ */
+async function installOne(type, author, pluginName, gitHubToken, installed = new Set()) {
+  const key = `${type}:${author}/${pluginName}`;
+  if (installed.has(key)) {
+    log.info(`Skipping already-installed ${type} "${author}/${pluginName}"`);
+    return;
+  }
+  installed.add(key);
+
+  const paths = type === 'plugin'
+    ? [path.join('Public', 'Modules', pluginName), path.join('EvoJsDev', 'Modules', pluginName)]
+    : [path.join('Public', 'Themes', pluginName)];
+
+  // Skip clone if already present on disk
+  if (paths.every(p => fs.existsSync(p))) {
+    log.warn(`${type} "${pluginName}" already exists on disk, skipping clone.`);
+  } else {
+    log.info(`Installing ${type} "${pluginName}" from ${author}...`);
+
+    if (type === 'plugin') {
+      await cloneRepo(`${author}/${pluginName}`, null, paths[0]);
+      await cloneRepo(`${author}/${pluginName}.js`, null, paths[1]);
+
+      const configFile = path.resolve(`./EvoJsDev/Modules/${pluginName}/config.json`);
+      if (fs.existsSync(configFile)) {
+        const pluginConfig = require(configFile);
+        mergeConfig(pluginConfig, "./config.json", false);
+      }
+
+      let newJsDep = await extractDependencies(paths[1], 'js');
+      jsDep = await mergeDependencies(newJsDep, jsDep);
+
+      let newPhpDep = await extractDependencies(paths[0], 'php');
+      phpDep = await mergeDependencies(newPhpDep, phpDep);
+
+    } else if (type === 'theme') {
+      await cloneRepo(`${author}/${pluginName}`, null, paths[0]);
+    }
+  }
+
+  // Read dependencies.json to find dependent evophp plugins/themes
+  const depFile = type === 'plugin'
+    ? path.join('EvoJsDev', 'Modules', pluginName, 'dependencies.json')
+    : path.join('Public', 'Themes', pluginName, 'dependencies.json');
+
+  if (!fs.existsSync(depFile)) return;
+
+  let deps;
+  try {
+    deps = JSON.parse(fs.readFileSync(depFile, 'utf-8'));
+  } catch (err) {
+    log.warn(`Could not parse dependencies.json for ${type} "${pluginName}": ${err.message}`);
+    return;
+  }
+
+  // Recursively install dependent evophp plugins
+  const pluginDeps = (deps.plugin || '').split(' ').map(d => d.trim()).filter(Boolean);
+  for (const dep of pluginDeps) {
+    if (!dep.includes('/')) {
+      log.warn(`Skipping malformed plugin dependency "${dep}" (expected author/name)`);
+      continue;
+    }
+    const [depAuthor, depName] = dep.split('/');
+    log.info(`Installing dependent plugin "${dep}" required by ${type} "${pluginName}"...`);
+    await installOne('plugin', depAuthor, depName, gitHubToken, installed);
+  }
+
+  // Recursively install dependent evophp themes
+  const themeDeps = (deps.theme || '').split(' ').map(d => d.trim()).filter(Boolean);
+  for (const dep of themeDeps) {
+    if (!dep.includes('/')) {
+      log.warn(`Skipping malformed theme dependency "${dep}" (expected author/name)`);
+      continue;
+    }
+    const [depAuthor, depName] = dep.split('/');
+    log.info(`Installing dependent theme "${dep}" required by ${type} "${pluginName}"...`);
+    await installOne('theme', depAuthor, depName, gitHubToken, installed);
+  }
+}
+
 module.exports = {
   command: 'install [type] [name]',
   aliases: ['i'],
@@ -36,10 +128,8 @@ module.exports = {
       let gitHubToken = process.env.GITHUB_TOKEN;
 
       if (name.includes("/")) {
-        // Full author/name provided — no auth required
         [author, pluginName] = name.split("/");
       } else {
-        // Token required to determine user
         if (!gitHubToken) {
           gitHubToken = await readLineAsync("Enter your GitHub Personal Access Token: ");
           saveToEnv("GITHUB_TOKEN", gitHubToken);
@@ -51,6 +141,7 @@ module.exports = {
         log.info(`Authenticated as ${author}`);
       }
 
+      // Guard: exit early if the top-level target already exists
       const paths = type === 'plugin'
         ? [path.join('Public', 'Modules', pluginName), path.join('EvoJsDev', 'Modules', pluginName)]
         : [path.join('Public', 'Themes', pluginName)];
@@ -62,24 +153,14 @@ module.exports = {
         }
       }
 
-      log.info(`Installing ${type} "${pluginName}" from ${author}...`);
-
-      if (type === 'plugin') {
-        await cloneRepo(`${author}/${pluginName}`, null, paths[0]);
-        await cloneRepo(`${author}/${pluginName}.js`, null, paths[1]);
+      // Shared Set across the entire install tree to prevent duplicate/circular installs
+      const installed = new Set();
+      await installOne(type, author, pluginName, gitHubToken, installed);
 
-        const configFile = path.resolve(`./EvoJsDev/Modules/${pluginName}/config.json`);
-        if (fs.existsSync(configFile)) {
-          const pluginConfig = require(configFile);
-          mergeConfig(pluginConfig);
-        }
-
-        await installDependencies(paths[1], 'js');
-        await installDependencies(paths[0], 'php');
+      await installDependencies(jsDep, 'js');
+      await installDependencies(phpDep, 'php');
 
-      } else if (type === 'theme') {
-        await cloneRepo(`${author}/${pluginName}`, null, paths[0]);
-      }
+      mergeConfig({});
 
       log.success(`The ${type} "${pluginName}" has been installed successfully.`);
 

package/commands/uninstall.js

@@ -5,6 +5,139 @@ const editJsonFile = require("edit-json-file");
 const { readLineAsync } = require("../utils/helpers");
 const log = require("../utils/logger");
 
+/**
+ * Returns all installed plugin and theme names as { type, name } objects.
+ */
+function getInstalledItems() {
+  const items = [];
+
+  const pluginDir = path.join("Public", "Modules");
+  if (fs.existsSync(pluginDir)) {
+    fs.readdirSync(pluginDir).forEach(name => {
+      if (fs.statSync(path.join(pluginDir, name)).isDirectory()) {
+        items.push({ type: "plugin", name });
+      }
+    });
+  }
+
+  const themeDir = path.join("Public", "Themes");
+  if (fs.existsSync(themeDir)) {
+    fs.readdirSync(themeDir).forEach(name => {
+      if (fs.statSync(path.join(themeDir, name)).isDirectory()) {
+        items.push({ type: "theme", name });
+      }
+    });
+  }
+
+  return items;
+}
+
+/**
+ * Reads the dependencies.json for a given installed item.
+ * Returns parsed object or null if absent/unreadable.
+ *
+ * @param {'plugin'|'theme'} type
+ * @param {string} name
+ */
+function readDepsFile(type, name) {
+  const depFile = type === "plugin"
+    ? path.join("EvoJsDev", "Modules", name, "dependencies.json")
+    : path.join("Public", "Themes", name, "dependencies.json");
+
+  if (!fs.existsSync(depFile)) return null;
+
+  try {
+    return JSON.parse(fs.readFileSync(depFile, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Finds all installed plugins/themes that declare a dependency on the target.
+ * Returns array of { type, name } of the dependents.
+ *
+ * @param {'plugin'|'theme'} targetType
+ * @param {string} targetName  - just the name portion (e.g. "Invoice"), matched
+ *                               against both "name" and "author/name" entries
+ */
+function findDependents(targetType, targetName) {
+  const dependents = [];
+  const depKey = targetType === "plugin" ? "plugin" : "theme";
+
+  for (const item of getInstalledItems()) {
+    // Don't check the item against itself
+    if (item.type === targetType && item.name === targetName) continue;
+
+    const deps = readDepsFile(item.type, item.name);
+    if (!deps || !deps[depKey]) continue;
+
+    const listed = deps[depKey]
+      .split(" ")
+      .map(d => d.trim())
+      .filter(Boolean);
+
+    const isDependent = listed.some(d => {
+      // Match "Invoice" or "kinsokafor/Invoice"
+      const parts = d.split("/");
+      return parts[parts.length - 1] === targetName;
+    });
+
+    if (isDependent) {
+      dependents.push(item);
+    }
+  }
+
+  return dependents;
+}
+
+/**
+ * Uninstalls a single plugin or theme after checking for dependents.
+ * Returns true if removed, false if retained due to dependents.
+ *
+ * @param {'plugin'|'theme'} type
+ * @param {string} name
+ * @param {boolean} force  - skip dependent check (used when caller already confirmed)
+ */
+async function uninstallOne(type, name, force = false) {
+  const paths = type === "plugin"
+    ? [path.join("Public", "Modules", name), path.join("EvoJsDev", "Modules", name)]
+    : [path.join("Public", "Themes", name)];
+
+  const existing = paths.filter(fs.existsSync);
+  if (existing.length === 0) {
+    log.warn(`${type} "${name}" not found on disk, skipping.`);
+    return false;
+  }
+
+  if (!force) {
+    const dependents = findDependents(type, name);
+    if (dependents.length > 0) {
+      const depList = dependents.map(d => `${d.type} "${d.name}"`).join(", ");
+      log.warn(`Skipping ${type} "${name}" — still required by: ${depList}`);
+      return false;
+    }
+  }
+
+  for (const dir of existing) {
+    rimraf.sync(dir);
+    log.success(`Deleted: ${dir}`);
+  }
+
+  if (type === "plugin") {
+    const configPath = path.resolve("config.json");
+    if (fs.existsSync(configPath)) {
+      let file = editJsonFile(configPath);
+      file.unset(`modules.${name}`);
+      file.save();
+      log.success(`Removed '${name}' from config.json`);
+    }
+  }
+
+  log.success(`${type} "${name}" uninstalled.`);
+  return true;
+}
+
 module.exports = {
   command: "uninstall [type] [name]",
   aliases: ["u"],
@@ -36,13 +169,11 @@ module.exports = {
         }
       }
 
-      const paths =
-        type === "plugin"
-          ? [path.join("Public", "Modules", name), path.join("EvoJsDev", "Modules", name)]
-          : [path.join("Public", "Themes", name)];
+      const paths = type === "plugin"
+        ? [path.join("Public", "Modules", name), path.join("EvoJsDev", "Modules", name)]
+        : [path.join("Public", "Themes", name)];
 
       const existing = paths.filter(fs.existsSync);
-
       if (existing.length === 0) {
         log.warn(`No matching ${type} found for "${name}".`);
         process.exit(0);
@@ -57,18 +188,27 @@ module.exports = {
         return;
       }
 
-      for (const dir of existing) {
-        rimraf.sync(dir);
-        log.success(`Deleted: ${dir}`);
-      }
+      // Remove the main target
+      await uninstallOne(type, name, true);
+
+      // Now attempt to remove its evophp dependencies, retaining any still used elsewhere
+      const deps = readDepsFile(type, name);
+      if (deps) {
+        const pluginDeps = (deps.plugin || "").split(" ").map(d => d.trim()).filter(Boolean);
+        const themeDeps  = (deps.theme  || "").split(" ").map(d => d.trim()).filter(Boolean);
+
+        if (pluginDeps.length > 0 || themeDeps.length > 0) {
+          log.info(`Checking evophp dependencies of "${name}" for removal...`);
+        }
+
+        for (const dep of pluginDeps) {
+          const depName = dep.includes("/") ? dep.split("/").pop() : dep;
+          await uninstallOne("plugin", depName);
+        }
 
-      if (type === "plugin") {
-        const configPath = path.resolve("config.json");
-        if (fs.existsSync(configPath)) {
-          let file = editJsonFile(configPath);
-          file.unset(`modules.${name}`);
-          file.save();
-          log.success(`Removed '${name}' from config.json`);
+        for (const dep of themeDeps) {
+          const depName = dep.includes("/") ? dep.split("/").pop() : dep;
+          await uninstallOne("theme", depName);
         }
       }
 
@@ -78,4 +218,4 @@ module.exports = {
       process.exit(1);
     }
   }
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evophp",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Command-line installer for the Evolution PHP framework",
   "bin": {
     "evophp": "bin/evophp.js"

package/utils/dependencies.js

@@ -3,31 +3,59 @@ const path = require('path');
 const { execSync } = require('child_process');
 const log = require('./logger');
 
-async function installDependencies(dir, type) {
-  const dependenciesFile = path.join(dir, 'dependencies.json');
-  if (!fs.existsSync(dependenciesFile)) {
-    log.info(`No ${type} dependencies.json found in ${dir}`);
-    return;
-  }
-
-  const deps = JSON.parse(fs.readFileSync(dependenciesFile, 'utf-8'));
+async function installDependencies(deps, type) {
   const cwd = process.cwd();
 
   if (type === 'js') {
-    if (deps.prod) {
+    if (deps.prod && (deps.prod || "").trim() != "") {
       log.info("Installing JS production dependencies...");
       execSync(`npm install ${deps.prod}`, { cwd, stdio: 'inherit' });
     }
-    if (deps.dev) {
+    if (deps.dev && (deps.dev || "").trim() != "") {
       log.info("Installing JS development dependencies...");
       execSync(`npm install ${deps.dev} --save-dev`, { cwd, stdio: 'inherit' });
     }
   }
 
-  if (type === 'php' && deps.prod) {
+  if (type === 'php' && deps.prod && (deps.prod || "").trim() != "") {
     log.info("Installing PHP dependencies...");
     execSync(`composer require ${deps.prod}`, { cwd, stdio: 'inherit' });
   }
 }
 
-module.exports = { installDependencies };
+async function extractDependencies(dir, type)
+{
+  const dependenciesFile = path.join(dir, 'dependencies.json');
+  if (!fs.existsSync(dependenciesFile)) {
+    log.info(`No ${type} dependencies.json found in ${dir}`);
+    return;
+  }
+
+  const deps = JSON.parse(fs.readFileSync(dependenciesFile, 'utf-8'));
+
+  return deps;
+}
+
+async function mergeDependencies(newDep, oldDep) {
+    const res = await new Promise((resolve) => {
+        for (const key in newDep) {
+            if (oldDep[key]) {
+                oldDep[key] = [
+                    ...new Set(
+                        `${oldDep[key]} ${newDep[key]}`
+                            .trim()
+                            .split(/\s+/)
+                            .filter(Boolean)
+                    )
+                ].join(" ");
+            } else {
+                oldDep[key] = String(newDep[key]).trim();
+            }
+        }
+        resolve(oldDep);
+    });
+
+    return res;
+}
+
+module.exports = { installDependencies, extractDependencies, mergeDependencies };

package/utils/helpers.js

@@ -67,7 +67,7 @@ const mergeDeep = async (target, source) => {
   return target;
 };
 
-const mergeConfig = async (config, filePath = "./config.json") => {
+const mergeConfig = async (config, filePath = "./config.json", runConfig = true) => {
   const file = editJsonFile(filePath);
   for (const key in config) {
     const existing = file.get(key);
@@ -83,12 +83,14 @@ const mergeConfig = async (config, filePath = "./config.json") => {
   }
   file.save();
 
-  // Run build process if entry config changes
-  try {
-    console.log("\n[INFO] Running npm run dev to recompile JS bundle...");
-    execSync("npm run dev", { stdio: "inherit" });
-  } catch (error) {
-    console.error("[ERROR] Failed to run 'npm run dev':", error.message);
+  if(runConfig) {
+    // Run build process if entry config changes
+    try {
+      console.log("\n[INFO] Running npm run dev to recompile JS bundle...");
+      execSync("npm run dev", { stdio: "inherit" });
+    } catch (error) {
+      console.error("[ERROR] Failed to run 'npm run dev':", error.message);
+    }
   }
 };