evophp 1.0.31 → 1.1.1

package/commands/new.js

@@ -0,0 +1,161 @@
+const path = require("path");
+const fs = require("fs");
+const { readLineAsync, mergeConfig } = require("../utils/helpers");
+const { getUserData, createGitHubRepo } = require("../utils/github");
+const { cloneRepo } = require("../utils/git");
+const { editFile, renameFile } = require("../utils/edit");
+const { test } = require("../utils/validate");
+const log = require("../utils/logger");
+require("dotenv").config({ path: "./.env.development" });
+
+module.exports = {
+  command: "new <type> <name>",
+  aliases: ["n"],
+  describe: "Create a new plugin or theme from template",
+
+  builder: (yargs) =>
+    yargs
+      .positional("type", {
+        describe: "plugin or theme",
+        type: "string",
+      })
+      .positional("name", {
+        describe: "The plugin or theme name (without author)",
+        type: "string",
+      }),
+
+  handler: async ({ type, name }) => {
+    try {
+      let gitHubToken = process.env.GITHUB_TOKEN;
+
+      if (!gitHubToken) {
+        gitHubToken = await readLineAsync(
+          "Enter GitHub Personal Access Token: "
+        );
+        const { saveToEnv } = require("../utils/helpers");
+        saveToEnv("GITHUB_TOKEN", gitHubToken);
+        log.success("GitHub token saved to .env.development");
+      }
+      type = type.toLowerCase();
+
+      if (!["plugin", "theme"].includes(type)) {
+        log.error("Invalid type. Must be plugin or theme.");
+        process.exit(1);
+      }
+
+      // Get authenticated username from token
+      const userData = await getUserData(gitHubToken);
+      const author = userData.login;
+      const pluginName = name;
+
+      log.info(`Authenticated as ${author}`);
+      log.info(`Creating ${type} "${pluginName}"...`);
+
+      if (type === "plugin") {
+        const entry = await setupPlugin(gitHubToken, author, pluginName);
+        log.success(`Plugin "${pluginName}" created with entry "${entry}"`);
+      } else {
+        await setupTheme(gitHubToken, author, pluginName);
+        log.success(`Theme "${pluginName}" created`);
+      }
+    } catch (err) {
+      log.error(`Creation failed: ${err.message}`);
+      process.exit(1);
+    }
+  },
+};
+
+async function setupPlugin(token, author, pluginName) {
+  const entry = await setupPluginRepo(token, author, pluginName);
+  const pluginPrefix = entry.replace("Main", "");
+
+  await editFile(`./Public/Modules/${pluginName}/Routes.php`, {
+    pluginName,
+    entry,
+    entryURI: entry.toLowerCase(),
+    pluginPrefix,
+  });
+
+  const controllerPath = `./Public/Modules/${pluginName}/Controller.php`;
+  if (fs.existsSync(controllerPath)) {
+    await editFile(controllerPath, { pluginName, pluginPrefix });
+    await renameFile(
+      controllerPath,
+      `./Public/Modules/${pluginName}/${pluginPrefix}Controller.php`
+    );
+    await renameFile(
+      `./Public/Modules/${pluginName}/Views/Entry`,
+      `./Public/Modules/${pluginName}/Views/${entry}`
+    );
+  }
+
+  return entry;
+}
+
+async function setupPluginRepo(token, author, pluginName) {
+  await createGitHubRepo(token, "kinsokafor/EvoPlugin", pluginName);
+  await cloneRepo(
+    author,
+    pluginName,
+    path.join("Public", "Modules", pluginName)
+  );
+
+  await createGitHubRepo(token, "kinsokafor/EvoPlugin.js", `${pluginName}.js`);
+  await cloneRepo(
+    author,
+    `${pluginName}.js`,
+    path.join("EvoJsDev", "Modules", pluginName)
+  );
+
+  const pluginPrefix = await getValidatedInput("Enter Plugin Prefix?", 3, true);
+  const entryURI = await getValidatedInput("Entry URI?", 20);
+  const entry = pluginPrefix + "Main";
+
+  await editFile(`./EvoJsDev/Modules/${pluginName}/config.json`, {
+    pluginName,
+    entry,
+  });
+  await renameFile(
+    `./EvoJsDev/Modules/${pluginName}/Entry`,
+    `./EvoJsDev/Modules/${pluginName}/${entry}`
+  );
+
+  const configPath = `./EvoJsDev/Modules/${pluginName}/config.json`;
+  if (fs.existsSync(configPath)) {
+    const pluginConfig = require(path.resolve(configPath));
+    mergeConfig(pluginConfig);
+  }
+
+  return entry;
+}
+
+async function setupTheme(token, author, pluginName) {
+  await createGitHubRepo(token, "kinsokafor/EvoTheme", pluginName);
+  await cloneRepo(
+    author,
+    pluginName,
+    path.join("Public", "Themes", pluginName)
+  );
+
+  await editFile(`./Public/Themes/${pluginName}/Data/index.data.php`, {
+    pluginName,
+  });
+  await editFile(`./Public/Themes/${pluginName}/Data/login.data.php`, {
+    pluginName,
+  });
+  await editFile(`./Public/Themes/${pluginName}/Views/index.blade.php`, {
+    pluginName,
+  });
+  await editFile(`./Public/Themes/${pluginName}/Views/login.blade.php`, {
+    pluginName,
+  });
+}
+
+async function getValidatedInput(label, maxLength, caps = false) {
+  let input = await readLineAsync(label);
+  while (!test(input, maxLength)) {
+    input = await readLineAsync(label);
+  }
+  input = input.trim().replaceAll(" ", "");
+  return caps ? input.toUpperCase() : input.toLowerCase();
+}

package/commands/uninstall.js

@@ -0,0 +1,81 @@
+const fs = require("fs");
+const path = require("path");
+const rimraf = require("rimraf");
+const editJsonFile = require("edit-json-file");
+const { readLineAsync } = require("../utils/helpers");
+const log = require("../utils/logger");
+
+module.exports = {
+  command: "uninstall [type] [name]",
+  aliases: ["u"],
+  describe: "Uninstall a plugin or theme",
+
+  builder: yargs =>
+    yargs
+      .positional("type", { describe: "plugin or theme", type: "string" })
+      .positional("name", { describe: "The plugin or theme name", type: "string" }),
+
+  handler: async ({ type, name }) => {
+    try {
+      // Prompt type if missing
+      if (!type || !["plugin", "theme"].includes(type.toLowerCase())) {
+        type = await readLineAsync("What are you uninstalling? (plugin/theme): ");
+        type = type.toLowerCase();
+        if (!["plugin", "theme"].includes(type)) {
+          log.error("Invalid type. Must be 'plugin' or 'theme'.");
+          process.exit(1);
+        }
+      }
+
+      // Prompt name if missing
+      if (!name) {
+        name = await readLineAsync(`Enter the ${type} name (e.g., example${type}): `);
+        if (!name) {
+          log.error("You must provide a name.");
+          process.exit(1);
+        }
+      }
+
+      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);
+      }
+
+      log.info(`Preparing to uninstall ${type} "${name}" from:`);
+      existing.forEach(p => log.info(" - " + p));
+
+      const confirm = await readLineAsync("Are you sure you want to proceed? (y/n): ");
+      if (!["y", "yes"].includes(confirm.trim().toLowerCase())) {
+        log.warn("Uninstallation cancelled.");
+        return;
+      }
+
+      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(`The ${type} "${name}" has been uninstalled successfully.`);
+    } catch (err) {
+      log.error("Error during uninstall: " + err.message);
+      process.exit(1);
+    }
+  }
+};

package/package.json

@@ -1,26 +1,33 @@
 {
   "name": "evophp",
-  "version": "1.0.31",
-  "description": "Installer for the Evolution PHP project",
-  "main": "installer.js",
-  "scripts": {
-    "start": "node installer.js"
-  },
+  "version": "1.1.01",
+  "description": "Command-line installer for the Evolution PHP framework",
   "bin": {
-    "evophp": "installer.js"
+    "evophp": "./bin/evophp.js"
+  },
+  "main": "bin/evophp.js",
+  "scripts": {
+    "start": "node bin/evophp.js"
   },
+  "files": [
+    "bin/",
+    "commands/",
+    "utils/"
+  ],
   "dependencies": {
     "axios": "^1.7.9",
     "dotenv": "^16.4.7",
     "edit-json-file": "^1.8.0",
-    "rimraf": "^6.0.1"
+    "rimraf": "^6.0.1",
+    "yargs": "^17.7.2"
   },
-  "files": [
-    "installer.js",
-    "new-plugin.js",
-    "install-plugin.js",
-    "install-dependencies.js",
-    "helpers.js",
-    "uninstall.js"
-  ]
-}
+  "keywords": [
+    "cli",
+    "evophp",
+    "installer",
+    "php-framework",
+    "evolution"
+  ],
+  "author": "Kingsley Okafor",
+  "license": "MIT"
+}

package/utils/config.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+const path = require('path');
+const configPath = path.join(require('os').homedir(), '.evophp-cli.json');
+
+function loadConfig() {
+  if (fs.existsSync(configPath)) {
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  }
+  return {};
+}
+
+function saveConfig(data) {
+  fs.writeFileSync(configPath, JSON.stringify(data, null, 2));
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  configPath
+};

package/utils/dependencies.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+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'));
+  const cwd = process.cwd();
+
+  if (type === 'js') {
+    if (deps.prod) {
+      log.info("Installing JS production dependencies...");
+      execSync(`npm install ${deps.prod}`, { cwd, stdio: 'inherit' });
+    }
+    if (deps.dev) {
+      log.info("Installing JS development dependencies...");
+      execSync(`npm install ${deps.dev} --save-dev`, { cwd, stdio: 'inherit' });
+    }
+  }
+
+  if (type === 'php' && deps.prod) {
+    log.info("Installing PHP dependencies...");
+    execSync(`composer require ${deps.prod}`, { cwd, stdio: 'inherit' });
+  }
+}
+
+module.exports = { installDependencies };

package/utils/edit.js

@@ -0,0 +1,42 @@
+const fs = require("fs");
+const path = require("path");
+const log = require("./logger");
+
+async function editFile(file, data) {
+  return new Promise((resolve, reject) => {
+    fs.readFile(file, "utf8", (err, fileData) => {
+      if (err) {
+        log.error(`Failed to read file ${file}`);
+        return reject(err);
+      }
+
+      for (const key in data) {
+        fileData = fileData.replaceAll(`<${key}>`, data[key]);
+      }
+
+      fs.writeFile(file, fileData, "utf8", err => {
+        if (err) {
+          log.error(`Failed to write file ${file}`);
+          return reject(err);
+        }
+        log.success(`${file} updated.`);
+        resolve(file);
+      });
+    });
+  });
+}
+
+async function renameFile(oldPath, newPath) {
+  return new Promise((resolve, reject) => {
+    fs.rename(oldPath, newPath, err => {
+      if (err) {
+        log.error(`Failed to rename ${oldPath}`);
+        return reject(err);
+      }
+      log.success(`Renamed: ${path.basename(oldPath)} → ${path.basename(newPath)}`);
+      resolve();
+    });
+  });
+}
+
+module.exports = { editFile, renameFile };

package/utils/git.js

@@ -0,0 +1,46 @@
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const rimraf = require("rimraf");
+const log = require("./logger");
+
+/**
+ * Clone a GitHub repo into a destination folder.
+ * Supports:
+ *   cloneRepo("author", "repo", "dest")
+ *   cloneRepo("author/repo", null, "dest")
+ *
+ * @param {string} authorOrFull - GitHub username OR "author/repo"
+ * @param {string|null} repo - Optional repo name if not included in first arg
+ * @param {string} dest - Local destination path
+ */
+async function cloneRepo(authorOrFull, repo, dest) {
+  let author = "";
+  let repoName = "";
+
+  if (repo === null || repo === undefined) {
+    // authorOrFull is in "author/repo" format
+    const parts = authorOrFull.split("/");
+    if (parts.length !== 2) {
+      log.error("Invalid GitHub repo format. Use 'author/repo'.");
+      process.exit(1);
+    }
+    [author, repoName] = parts;
+  } else {
+    // Passed separately
+    author = authorOrFull;
+    repoName = repo;
+  }
+
+  const cloneUrl = `https://github.com/${author}/${repoName}.git`;
+
+  if (fs.existsSync(dest)) {
+    log.warn(`Deleting existing folder: ${dest}`);
+    rimraf.sync(dest);
+  }
+
+  log.info(`Cloning ${author}/${repoName} → ${dest}`);
+  execSync(`git clone ${cloneUrl} ${dest}`, { stdio: "inherit" });
+}
+
+module.exports = { cloneRepo };

package/utils/github.js

@@ -0,0 +1,49 @@
+// utils/github.js
+const axios = require("axios");
+const log = require("./logger");
+
+async function getUserData(token) {
+  try {
+    const res = await axios.get("https://api.github.com/user", {
+      headers: {
+        Authorization: `token ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    });
+    return res.data;
+  } catch (e) {
+    log.error("Failed to fetch GitHub user info.");
+    throw e;
+  }
+}
+
+async function createGitHubRepo(token, templateRepo, pluginName) {
+  try {
+    const res = await axios.post(
+      `https://api.github.com/repos/${templateRepo}/generate`,
+      {
+        name: pluginName,
+        private: true,
+        description: `A new ${templateRepo.split("/")[1]} created from template.`,
+      },
+      {
+        headers: {
+          Authorization: `token ${token}`,
+          Accept: "application/vnd.github.v3+json",
+        },
+      }
+    );
+
+    if (res.status === 201) {
+      log.success(`Created repo ${pluginName} from ${templateRepo}`);
+    } else {
+      log.error("Failed to create repo:", res.data);
+      process.exit(1);
+    }
+  } catch (e) {
+    log.error(`GitHub repo creation failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { getUserData, createGitHubRepo };

package/utils/helpers.js

@@ -0,0 +1,161 @@
+const readline = require("readline");
+const editJsonFile = require("edit-json-file");
+
+/**
+ * Prompt user for input with a message
+ * @param {string} msg - The prompt message to display
+ * @returns {Promise<string>}
+ */
+const readLineAsync = (msg) => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(msg, (userRes) => {
+      resolve(userRes.trim());
+      rl.close();
+    });
+  });
+};
+
+/**
+ * Validate and split a name into [author, pluginName]
+ * Accepts "author/plugin" or a GitHub URL
+ * @param {string} name
+ * @returns {Promise<[string, string]>}
+ */
+const splitPluginName = async (name) => {
+  const isValid = (input) =>
+    /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(input);
+
+  while (true) {
+    name = name.replace(/^(https?:\/\/)?(www\.)?github\.com\//, "").trim();
+    if (isValid(name)) return name.split("/");
+
+    console.log("Format must be: author/plugin-name");
+    name = await readLineAsync("Enter the plugin name (or 'cancel' to exit): ");
+    if (name.toLowerCase() === "cancel") {
+      console.log("Process canceled by user.");
+      process.exit(1);
+    }
+  }
+};
+
+/**
+ * Check if value is a plain object
+ */
+const isObject = (item) =>
+  item && typeof item === "object" && !Array.isArray(item);
+
+/**
+ * Deep merge multiple objects into one
+ */
+const mergeDeep = async (target, ...sources) => {
+  if (!sources.length) return target;
+  const source = sources.shift();
+
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key]) Object.assign(target, { [key]: {} });
+        await mergeDeep(target[key], source[key]);
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+
+  return mergeDeep(target, ...sources);
+};
+
+/**
+ * Merge plugin config into config.json
+ */
+const mergeConfig = async (config) => {
+  const file = editJsonFile("./config.json");
+
+  for (const key in config) {
+    const existing = file.get(key);
+    if (existing === undefined) {
+      file.set(key, config[key]);
+    } else if (isObject(existing)) {
+      const merged = await mergeDeep(existing, config[key]);
+      file.set(key, merged);
+    } else {
+      file.set(key, config[key]);
+    }
+  }
+
+  file.save();
+};
+
+/**
+ * Add a new entry point to a plugin's config.json file
+ * @param {string} pluginName - The plugin name
+ * @param {string} entryName - The entry directory name
+ */
+function addPluginEntry(pluginName, entryName) {
+  const configPath = path.join("EvoJsDev", "Modules", pluginName, "config.json");
+
+  if (!fs.existsSync(configPath)) {
+    log.error(`Config file not found: ${configPath}`);
+    return;
+  }
+
+  const file = editJsonFile(configPath);
+  const entryPath = `${entryName}/index`;
+
+  const current = file.get(`modules.${pluginName}`) || {
+    entry: [],
+    active: true,
+    order: 0
+  };
+
+  if (!current.entry.includes(entryPath)) {
+    current.entry.push(entryPath);
+  }
+
+  file.set(`modules.${pluginName}`, current);
+  file.save();
+  log.success(`Added entry "${entryPath}" to ${pluginName} config.`);
+}
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Save a key-value pair to .env.development (creates or updates)
+ * @param {string} key
+ * @param {string} value
+ */
+function saveToEnv(key, value) {
+  const envPath = path.resolve(".env.development");
+
+  let env = "";
+  if (fs.existsSync(envPath)) {
+    env = fs.readFileSync(envPath, "utf-8");
+  }
+
+  const regex = new RegExp(`^${key}=.*$`, "m");
+  const line = `${key}=${value.trim()}`;
+
+  if (regex.test(env)) {
+    // Update existing key
+    env = env.replace(regex, line);
+  } else {
+    // Append new key
+    env += (env.endsWith("\n") ? "" : "\n") + line + "\n";
+  }
+
+  fs.writeFileSync(envPath, env, "utf-8");
+}
+
+module.exports = {
+  readLineAsync,
+  splitPluginName,
+  mergeConfig,
+  addPluginEntry,
+  saveToEnv
+};

package/utils/logger.js

@@ -0,0 +1,6 @@
+module.exports = {
+  info: msg => console.log(`[INFO] ${msg}`),
+  error: msg => console.error(`[ERROR] ${msg}`),
+  success: msg => console.log(`[✓] ${msg}`),
+  warn: msg => console.warn(`[WARN] ${msg}`)
+};

package/utils/validate.js

@@ -0,0 +1,16 @@
+const log = require("./logger");
+
+function test(str, maxLength) {
+  str = str.trim().replaceAll(" ", "");
+  if (str.length > maxLength) {
+    log.error(`Input can't exceed ${maxLength} characters.`);
+    return false;
+  }
+  if (str.length < 1) {
+    log.error(`Input is empty.`);
+    return false;
+  }
+  return str;
+}
+
+module.exports = { test };