@exilonstudios/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1275 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { intro, outro } from "@clack/prompts";
+import chalk6 from "chalk";
+import gradient from "gradient-string";
+
+// src/commands/new.ts
+import { select, text, confirm, multiselect, cancel } from "@clack/prompts";
+import chalk from "chalk";
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import { execa } from "execa";
+import { Listr } from "listr2";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var PLUGIN_STARTERS = [
+  { value: "basic", label: "\u{1F4E6} Basic Plugin", hint: "Minimal plugin structure" },
+  { value: "blog", label: "\u{1F4DD} Blog Extension", hint: "Extend blog functionality" },
+  { value: "shop", label: "\u{1F6D2} Shop Integration", hint: "E-commerce integration" },
+  { value: "analytics", label: "\u{1F4CA} Analytics Provider", hint: "Custom analytics tracking" },
+  { value: "notification", label: "\u{1F514} Notification Channel", hint: "Custom notification channel" }
+];
+var THEME_STARTERS = [
+  { value: "minimal", label: "\u{1F3A8} Minimal Theme", hint: "Clean, minimal design" },
+  { value: "blog", label: "\u{1F4F0} Blog Theme", hint: "Content-focused blog theme" },
+  { value: "gaming", label: "\u{1F3AE} Gaming Theme", hint: "Gaming server theme" },
+  { value: "portfolio", label: "\u{1F4BC} Portfolio Theme", hint: "Personal portfolio theme" }
+];
+var PLUGIN_FEATURES = [
+  { value: "admin", label: "\u{1F527} Admin Panel", hint: "Backend admin interface" },
+  { value: "public", label: "\u{1F310} Public Pages", hint: "Frontend user-facing pages" },
+  { value: "api", label: "\u{1F50C} API Routes", hint: "REST API endpoints" },
+  { value: "models", label: "\u{1F4CA} Database Models", hint: "Eloquent models" },
+  { value: "middleware", label: "\u{1F6E1}\uFE0F Middleware", hint: "Custom middleware" },
+  { value: "commands", label: "\u2328\uFE0F Artisan Commands", hint: "Console commands" },
+  { value: "react", label: "\u269B\uFE0F React Components", hint: "React + Inertia pages" },
+  { value: "settings", label: "\u2699\uFE0F Settings Page", hint: "Configurable settings" }
+];
+var THEME_FEATURES = [
+  { value: "templates", label: "\u{1F4C4} Blade Templates", hint: "Blade view templates" },
+  { value: "assets", label: "\u{1F3A8} CSS/JS Assets", hint: "Frontend assets" },
+  { value: "config", label: "\u2699\uFE0F Theme Config", hint: "Customizable theme options" },
+  { value: "widgets", label: "\u{1F9E9} Widget Areas", hint: "Dynamic widget areas" },
+  { value: "colors", label: "\u{1F3A8} Color Schemes", hint: "Multiple color schemes" }
+];
+async function newCommand(typeArg) {
+  try {
+    let type;
+    if (typeArg && ["plugin", "theme"].includes(typeArg)) {
+      type = typeArg;
+    } else {
+      const typeSelect = await select({
+        message: "What do you want to create?",
+        options: [
+          { value: "plugin", label: "\u{1F50C} Plugin", hint: "Extend CMS functionality" },
+          { value: "theme", label: "\u{1F3A8} Theme", hint: "Customize the appearance" }
+        ]
+      });
+      if (typeof typeSelect !== "string") {
+        cancel("Operation cancelled");
+        process.exit(0);
+      }
+      type = typeSelect;
+    }
+    const name = await text({
+      message: `Project name (e.g., ${type === "plugin" ? "my-awesome-plugin" : "my-awesome-theme"}):`,
+      placeholder: type === "plugin" ? "my-awesome-plugin" : "my-awesome-theme",
+      validate: (value) => {
+        if (!value) return "Name is required";
+        if (!/^[a-z0-9-]+$/.test(value)) return "Use only lowercase letters, numbers, and hyphens";
+        if (value.length < 3) return "Name must be at least 3 characters";
+      }
+    });
+    if (typeof name !== "string") {
+      cancel("Operation cancelled");
+      process.exit(0);
+    }
+    const description = await text({
+      message: "Description:",
+      placeholder: `An amazing ${type} for ExilonCMS`
+    });
+    if (typeof description !== "string") {
+      cancel("Operation cancelled");
+      process.exit(0);
+    }
+    const author = await text({
+      message: "Author name:",
+      placeholder: "Your Name"
+    });
+    if (typeof author !== "string") {
+      cancel("Operation cancelled");
+      process.exit(0);
+    }
+    let namespace = "ExilonCMS\\Plugins\\" + toPascalCase(name);
+    if (type === "plugin") {
+      const namespaceInput = await text({
+        message: "PHP Namespace:",
+        placeholder: namespace,
+        initialValue: namespace
+      });
+      if (typeof namespaceInput !== "string") {
+        cancel("Operation cancelled");
+        process.exit(0);
+      }
+      namespace = namespaceInput;
+    }
+    const useStarter = await confirm({
+      message: `Use a starter ${type}?`,
+      initialValue: true
+    });
+    if (typeof useStarter !== "boolean") {
+      cancel("Operation cancelled");
+      process.exit(0);
+    }
+    let starter;
+    if (useStarter) {
+      const starters = type === "plugin" ? PLUGIN_STARTERS : THEME_STARTERS;
+      const starterSelect = await select({
+        message: `Choose a ${type} starter:`,
+        options: starters
+      });
+      if (typeof starterSelect !== "string") {
+        cancel("Operation cancelled");
+        process.exit(0);
+      }
+      starter = starterSelect;
+    }
+    const features = type === "plugin" ? PLUGIN_FEATURES : THEME_FEATURES;
+    const selectedFeatures = await multiselect({
+      message: `Select features (press space to select, enter to continue):`,
+      options: features,
+      required: false
+    });
+    if (!Array.isArray(selectedFeatures)) {
+      cancel("Operation cancelled");
+      process.exit(0);
+    }
+    const options = {
+      type,
+      name,
+      description: description || `An amazing ${type} for ExilonCMS`,
+      author: author || "Unknown",
+      version: "1.0.0",
+      license: "MIT",
+      useStarter,
+      starter,
+      features: selectedFeatures,
+      namespace
+    };
+    const shouldContinue = await confirm({
+      message: "Ready to create?",
+      initialValue: true
+    });
+    if (typeof shouldContinue !== "boolean" || !shouldContinue) {
+      cancel("Operation cancelled");
+      process.exit(0);
+    }
+    await createProject(options);
+  } catch (error) {
+    if (error instanceof Error && error.message !== "Operation cancelled") {
+      console.error(chalk.red("Error:"), error.message);
+    }
+  }
+}
+async function createProject(options) {
+  const tasks = new Listr([
+    {
+      title: "Creating project structure",
+      task: async () => {
+        const projectPath = path.join(process.cwd(), options.name);
+        await fs.ensureDir(projectPath);
+        if (options.type === "plugin") {
+          await createPluginStructure(projectPath, options);
+        } else {
+          await createThemeStructure(projectPath, options);
+        }
+      }
+    },
+    {
+      title: "Generating configuration files",
+      task: async () => {
+        const projectPath = path.join(process.cwd(), options.name);
+        await generateConfigFiles(projectPath, options);
+      }
+    },
+    {
+      title: "Creating source files",
+      task: async () => {
+        const projectPath = path.join(process.cwd(), options.name);
+        await generateSourceFiles(projectPath, options);
+      }
+    },
+    {
+      title: "Installing dependencies",
+      task: async () => {
+        const projectPath = path.join(process.cwd(), options.name);
+        if (options.type === "theme" && !options.features.includes("react")) {
+          return "Skipped (no npm dependencies)";
+        }
+        await execa("npm", ["install"], { cwd: projectPath });
+      }
+    },
+    {
+      title: "Initializing git repository",
+      task: async () => {
+        const projectPath = path.join(process.cwd(), options.name);
+        await execa("git", ["init"], { cwd: projectPath });
+      }
+    }
+  ]);
+  await tasks.run();
+}
+async function createPluginStructure(projectPath, options) {
+  const dirs = [
+    "src",
+    "src/Models",
+    "src/Http/Controllers",
+    "src/Http/Middleware",
+    "src/Http/Requests",
+    "database/migrations",
+    "routes",
+    "resources/views",
+    "resources/js",
+    "resources/css",
+    "config",
+    "tests"
+  ];
+  for (const dir of dirs) {
+    await fs.ensureDir(path.join(projectPath, dir));
+  }
+}
+async function createThemeStructure(projectPath, options) {
+  const dirs = [
+    "resources/views",
+    "resources/views/layouts",
+    "resources/views/components",
+    "resources/css",
+    "resources/js",
+    "config"
+  ];
+  for (const dir of dirs) {
+    await fs.ensureDir(path.join(projectPath, dir));
+  }
+}
+async function generateConfigFiles(projectPath, options) {
+  if (options.type === "plugin") {
+    const pluginJson = {
+      name: options.name,
+      version: options.version,
+      description: options.description,
+      author: options.author,
+      license: options.license,
+      type: "plugin",
+      namespace: options.namespace,
+      service_provider: `${options.namespace}\\${toPascalCase(options.name)}ServiceProvider`,
+      autoload: {
+        "psr-4": {
+          [options.namespace + "\\"]: "src/"
+        }
+      },
+      extras: {
+        "laravel": {
+          "providers": [
+            `${options.namespace}\\${toPascalCase(options.name)}ServiceProvider`
+          ]
+        }
+      }
+    };
+    await fs.writeJson(path.join(projectPath, "plugin.json"), pluginJson, { spaces: 2 });
+  }
+  if (options.type === "theme") {
+    const themeJson = {
+      name: options.name,
+      version: options.version,
+      description: options.description,
+      author: options.author,
+      license: options.license,
+      type: "theme",
+      screenshot: "screenshot.png",
+      supports: {
+        "exiloncms": "^1.0.0"
+      }
+    };
+    await fs.writeJson(path.join(projectPath, "theme.json"), themeJson, { spaces: 2 });
+  }
+  const packageJson = {
+    name: `exiloncms-${options.type}-${options.name}`,
+    version: options.version,
+    description: options.description,
+    author: options.author,
+    license: options.license,
+    private: true,
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview"
+    },
+    dependencies: {},
+    devDependencies: {
+      vite: "^5.0.0",
+      "@vitejs/plugin-react": "^4.2.0"
+    }
+  };
+  if (options.features.includes("react")) {
+    packageJson.dependencies = {
+      "react": "^18.2.0",
+      "react-dom": "^18.2.0",
+      "@inertiajs/react": "^1.0.0"
+    };
+    packageJson.devDependencies = {
+      ...packageJson.devDependencies,
+      "@types/react": "^18.2.0",
+      "@types/react-dom": "^18.2.0",
+      "typescript": "^5.0.0"
+    };
+  }
+  await fs.writeJson(path.join(projectPath, "package.json"), packageJson, { spaces: 2 });
+  if (options.type === "plugin") {
+    const composerJson = {
+      name: `exiloncms/${options.name}`,
+      description: options.description,
+      type: "exiloncms-plugin",
+      version: options.version,
+      license: options.license,
+      authors: [
+        { name: options.author }
+      ],
+      require: {
+        "php": "^8.2",
+        "laravel/framework": "^11.0"
+      },
+      autoload: {
+        "psr-4": {
+          [options.namespace + "\\"]: "src/"
+        }
+      },
+      "extra": {
+        "exiloncms": {
+          "name": options.name,
+          "namespace": options.namespace
+        }
+      },
+      minimumStability: "dev",
+      preferStable: true
+    };
+    await fs.writeJson(path.join(projectPath, "composer.json"), composerJson, { spaces: 2 });
+  }
+}
+async function generateSourceFiles(projectPath, options) {
+  if (options.type === "plugin") {
+    await generatePluginServiceProvider(projectPath, options);
+    await generatePluginRoutes(projectPath, options);
+  } else {
+    await generateThemeFiles(projectPath, options);
+  }
+  await generateReadme(projectPath, options);
+  await generateLicense(projectPath, options);
+  await generateGitignore(projectPath, options);
+}
+async function generatePluginServiceProvider(projectPath, options) {
+  const className = toPascalCase(options.name) + "ServiceProvider";
+  const content = `<?php
+
+namespace ${options.namespace};
+
+use Illuminate\\Support\\ServiceProvider;
+use Illuminate\\Support\\Facades\\Route;
+
+class ${className} extends ServiceProvider
+{
+    /**
+     * Bootstrap any package services.
+     */
+    public function boot(): void
+    {
+        // Load routes
+        $this->loadRoutesFrom(__DIR__ . '/../routes/web.php');
+        $this->loadRoutesFrom(__DIR__ . '/../routes/admin.php');
+
+        // Load views
+        $this->loadViewsFrom(__DIR__ . '/../resources/views', '${options.name}');
+
+        // Load migrations
+        $this->loadMigrationsFrom(__DIR__ . '/../database/migrations');
+
+        // Publish assets
+        $this->publishes([
+            __DIR__ . '/../resources/js' => public_path('vendor/${options.name}'),
+        ], ['${options.name}', '${options.name}-assets']);
+
+        // Publish config
+        if ($this->app->runningInConsole()) {
+            $this->publishes([
+                __DIR__ . '/../config/${options.name}.php' => config_path('${options.name}.php'),
+            ], '${options.name}-config');
+        }
+    }
+
+    /**
+     * Register any package services.
+     */
+    public function register(): void
+    {
+        // Merge config
+        $this->mergeConfigFrom(
+            __DIR__ . '/../config/${options.name}.php',
+            '${options.name}'
+        );
+    }
+}
+`;
+  await fs.writeFile(path.join(projectPath, "src", className + ".php"), content);
+}
+async function generatePluginRoutes(projectPath, options) {
+  const webRoutes = `<?php
+
+use Illuminate\\Support\\Facades\\Route;
+use ${options.namespace}\\Http\\Controllers\\ExampleController;
+
+// Public routes
+Route::prefix('${options.name}')->group(function () {
+    Route::get('/', [ExampleController::class, 'index'])->name('${options.name}.index');
+});
+`;
+  await fs.writeFile(path.join(projectPath, "routes", "web.php"), webRoutes);
+  const adminRoutes = `<?php
+
+use Illuminate\\Support\\Facades\\Route;
+use ${options.namespace}\\Http\\Controllers\\Admin\\ExampleController;
+
+// Admin routes
+Route::prefix('admin/${options.name}')
+    ->middleware(['web', 'auth', 'admin'])
+    ->group(function () {
+        Route::get('/', [ExampleController::class, 'index'])->name('admin.${options.name}.index');
+    });
+`;
+  await fs.writeFile(path.join(projectPath, "routes", "admin.php"), adminRoutes);
+}
+async function generateThemeFiles(projectPath, options) {
+  const layout = `<!DOCTYPE html>
+<html lang="{{ app()->getLocale() }}">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>@yield('title') - {{ setting('name') }}</title>
+    @vite(['resources/css/app.css', 'resources/js/app.js'])
+</head>
+<body class="antialiased">
+    @yield('content')
+
+    @stack('scripts')
+</body>
+</html>
+`;
+  await fs.writeFile(path.join(projectPath, "resources/views/layouts/app.blade.php"), layout);
+  const home = `@extends('layouts.app')
+
+@section('title', 'Home')
+
+@section('content')
+<div class="container mx-auto px-4 py-8">
+    <h1 class="text-4xl font-bold">Welcome to {{ $page->title ?? theme('name') }}</h1>
+    <p class="mt-4 text-gray-600">
+        {{ $page->content ?? 'This is the ' . theme('name') . ' theme.' }}
+    </p>
+</div>
+@endsection
+`;
+  await fs.writeFile(path.join(projectPath, "resources/views/home.blade.php"), home);
+}
+async function generateReadme(projectPath, options) {
+  const content = `# ${toPascalCase(options.name)}
+
+${options.description}
+
+## Author
+${options.author}
+
+## Version
+${options.version}
+
+## License
+${options.license}
+
+## Installation
+
+### For Plugins
+\`\`\`bash
+composer require exiloncms/${options.name}
+php artisan vendor:publish --tag="${options.name}"
+php artisan migrate
+\`\`\`
+
+### For Themes
+\`\`\`bash
+# Copy to themes directory
+cp -r ${options.name} /path/to/cms/themes/${options.name}
+
+# Or use the CLI
+exiloncms install ${options.name}
+\`\`\`
+
+## Usage
+
+${options.type === "plugin" ? '### Configuration\n\nPublish the config file:\n```bash\nphp artisan vendor:publish --tag="${options.name}-config"\n```' : "### Screenshot\n\n![Screenshot](screenshot.png)"}
+
+## Features
+
+${options.features.map((f) => `- ${f}`).join("\n")}
+
+## Development
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Build assets
+npm run build
+
+# Watch for changes
+npm run dev
+\`\`\`
+
+## Support
+
+For issues and feature requests, please create an issue on the repository.
+`;
+  await fs.writeFile(path.join(projectPath, "README.md"), content);
+}
+async function generateLicense(projectPath, options) {
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  const content = `MIT License
+
+Copyright (c) ${year} ${options.author}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+  await fs.writeFile(path.join(projectPath, "LICENSE"), content);
+}
+async function generateGitignore(projectPath, options) {
+  const content = `node_modules/
+dist/
+build/
+vendor/
+.env
+.env.local
+.DS_Store
+*.log
+coverage/
+.nyc_output/
+.cache/
+`;
+  await fs.writeFile(path.join(projectPath, ".gitignore"), content);
+}
+function toPascalCase(str) {
+  return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+
+// src/commands/install.ts
+import { select as select2, text as text2, confirm as confirm2, cancel as cancel2 } from "@clack/prompts";
+import chalk2 from "chalk";
+import fs2 from "fs-extra";
+import path2 from "path";
+import { execa as execa2 } from "execa";
+import axios from "axios";
+import { Listr as Listr2 } from "listr2";
+var MARKETPLACE_API = "https://marketplace.exiloncms.fr/api/v1";
+async function installCommand(nameArg) {
+  try {
+    let packageName;
+    if (nameArg) {
+      packageName = nameArg;
+    } else {
+      const searchTerm = await text2({
+        message: "Enter package name or search term:",
+        placeholder: "e.g., blog"
+      });
+      if (typeof searchTerm !== "string") {
+        cancel2("Operation cancelled");
+        process.exit(0);
+      }
+      const packages = await searchPackages(searchTerm);
+      if (packages.length === 0) {
+        console.log(chalk2.yellow("No packages found"));
+        return;
+      }
+      const selected = await select2({
+        message: "Select a package:",
+        options: packages.map((pkg) => ({
+          value: pkg.name,
+          label: pkg.name,
+          hint: pkg.description
+        }))
+      });
+      if (typeof selected !== "string") {
+        cancel2("Operation cancelled");
+        process.exit(0);
+      }
+      packageName = selected;
+    }
+    const packageInfo = await getPackageInfo(packageName);
+    console.log(chalk2.cyan("\n\u{1F4E6} Package Details:"));
+    console.log(chalk2.gray("\u2500".repeat(50)));
+    console.log(`${chalk2.bold("Name:")} ${packageInfo.name}`);
+    console.log(`${chalk2.bold("Version:")} ${packageInfo.version}`);
+    console.log(`${chalk2.bold("Description:")} ${packageInfo.description}`);
+    console.log(`${chalk2.bold("Author:")} ${packageInfo.author}`);
+    console.log(`${chalk2.bold("Type:")} ${packageInfo.type}`);
+    console.log(`${chalk2.bold("Requires:")} ${packageInfo.requires}`);
+    console.log(chalk2.gray("\u2500".repeat(50)));
+    const shouldInstall = await confirm2({
+      message: "Install this package?",
+      initialValue: true
+    });
+    if (typeof shouldInstall !== "boolean" || !shouldInstall) {
+      cancel2("Operation cancelled");
+      process.exit(0);
+    }
+    await installPackage(packageInfo);
+  } catch (error) {
+    if (error instanceof Error && error.message !== "Operation cancelled") {
+      console.error(chalk2.red("Error:"), error.message);
+    }
+  }
+}
+async function searchPackages(query) {
+  try {
+    const response = await axios.get(`${MARKETPLACE_API}/search`, {
+      params: { q: query }
+    });
+    return response.data.data || [];
+  } catch (error) {
+    console.log(chalk2.yellow("Note: Marketplace not available, searching local templates..."));
+    return getLocalTemplates();
+  }
+}
+async function getPackageInfo(name) {
+  try {
+    const response = await axios.get(`${MARKETPLACE_API}/packages/${name}`);
+    return response.data.data;
+  } catch (error) {
+    const local = getLocalTemplates().find((p) => p.name === name);
+    if (!local) {
+      throw new Error(`Package "${name}" not found`);
+    }
+    return local;
+  }
+}
+async function installPackage(packageInfo) {
+  const tasks = new Listr2([
+    {
+      title: "Downloading package",
+      task: async () => {
+        const downloadDir = path2.join(process.cwd(), ".exiloncms-temp");
+        await fs2.ensureDir(downloadDir);
+        const zipPath = path2.join(downloadDir, `${packageInfo.name}.zip`);
+        if (packageInfo.download_url) {
+          const response = await axios({
+            method: "GET",
+            url: packageInfo.download_url,
+            responseType: "stream"
+          });
+          const writer = fs2.createWriteStream(zipPath);
+          response.data.pipe(writer);
+          return new Promise((resolve, reject) => {
+            writer.on("finish", resolve);
+            writer.on("error", reject);
+          });
+        } else {
+          throw new Error("This package must be installed manually");
+        }
+      }
+    },
+    {
+      title: "Extracting package",
+      task: async () => {
+        const targetDir = packageInfo.type === "plugin" ? path2.join(process.cwd(), "plugins", packageInfo.name) : path2.join(process.cwd(), "themes", packageInfo.name);
+        await fs2.ensureDir(targetDir);
+        await execa2("unzip", ["-o", path2.join(process.cwd(), ".exiloncms-temp", `${packageInfo.name}.zip`), "-d", targetDir]);
+      }
+    },
+    {
+      title: "Installing dependencies",
+      task: async () => {
+        const packageDir = packageInfo.type === "plugin" ? path2.join(process.cwd(), "plugins", packageInfo.name) : path2.join(process.cwd(), "themes", packageInfo.name);
+        const composerJson = path2.join(packageDir, "composer.json");
+        const packageJson = path2.join(packageDir, "package.json");
+        if (await fs2.pathExists(composerJson)) {
+          await execa2("composer", ["install"], { cwd: packageDir });
+        }
+        if (await fs2.pathExists(packageJson)) {
+          await execa2("npm", ["install"], { cwd: packageDir });
+        }
+      }
+    },
+    {
+      title: "Running migrations",
+      task: async () => {
+        if (packageInfo.type === "plugin") {
+          await execa2("php", ["artisan", "migrate"], { cwd: process.cwd() });
+        }
+      }
+    },
+    {
+      title: "Cleaning up",
+      task: async () => {
+        await fs2.remove(path2.join(process.cwd(), ".exiloncms-temp"));
+      }
+    }
+  ]);
+  await tasks.run();
+}
+function getLocalTemplates() {
+  return [
+    {
+      name: "blog",
+      version: "1.0.0",
+      description: "Full-featured blog plugin",
+      author: "ExilonCMS",
+      type: "plugin",
+      download_url: "",
+      requires: ">=1.0.0"
+    },
+    {
+      name: "gaming-theme",
+      version: "1.0.0",
+      description: "Gaming server theme",
+      author: "ExilonCMS",
+      type: "theme",
+      download_url: "",
+      requires: ">=1.0.0"
+    }
+  ];
+}
+
+// src/commands/update.ts
+import { confirm as confirm3, cancel as cancel3, multiselect as multiselect2 } from "@clack/prompts";
+import chalk3 from "chalk";
+import { execa as execa3 } from "execa";
+import fs3 from "fs-extra";
+import path3 from "path";
+import axios2 from "axios";
+import { Listr as Listr3 } from "listr2";
+var MARKETPLACE_API2 = "https://marketplace.exiloncms.fr/api/v1";
+async function updateCommand(options) {
+  try {
+    let updatesAvailable = [];
+    const tasks = new Listr3([
+      {
+        title: "Checking for updates",
+        task: async () => {
+          updatesAvailable = await checkForUpdates();
+        }
+      }
+    ]);
+    await tasks.run();
+    if (updatesAvailable.length === 0) {
+      console.log(chalk3.green("\u2713 Everything is up to date!"));
+      return;
+    }
+    console.log(chalk3.cyan("\n\u{1F4E6} Available Updates:"));
+    console.log(chalk3.gray("\u2500".repeat(60)));
+    updatesAvailable.forEach((update) => {
+      const icon = update.type === "core" ? "\u2699\uFE0F" : update.type === "plugin" ? "\u{1F50C}" : "\u{1F3A8}";
+      console.log(`${icon} ${chalk3.bold(update.name)}`);
+      console.log(`   ${chalk3.gray(update.currentVersion)} \u2192 ${chalk3.green(update.latestVersion)}`);
+      console.log();
+    });
+    const selectedUpdates = await multiselect2({
+      message: "Select updates to install (space to select, enter to continue):",
+      options: updatesAvailable.map((update) => ({
+        value: update.name,
+        label: update.name,
+        hint: `${update.currentVersion} \u2192 ${update.latestVersion}`
+      })),
+      required: false
+    });
+    if (!Array.isArray(selectedUpdates)) {
+      cancel3("Operation cancelled");
+      process.exit(0);
+    }
+    if (selectedUpdates.length === 0) {
+      console.log(chalk3.yellow("No updates selected"));
+      return;
+    }
+    const shouldProceed = await confirm3({
+      message: `Install ${selectedUpdates.length} update(s)?`,
+      initialValue: true
+    });
+    if (typeof shouldProceed !== "boolean" || !shouldProceed) {
+      cancel3("Operation cancelled");
+      process.exit(0);
+    }
+    await installUpdates(updatesAvailable.filter((u) => selectedUpdates.includes(u.name)));
+  } catch (error) {
+    if (error instanceof Error && error.message !== "Operation cancelled") {
+      console.error(chalk3.red("Error:"), error.message);
+    }
+  }
+}
+async function checkForUpdates() {
+  const updates = [];
+  try {
+    const coreUpdate = await checkCoreUpdate();
+    if (coreUpdate) {
+      updates.push(coreUpdate);
+    }
+  } catch (error) {
+  }
+  try {
+    const pluginsDir = path3.join(process.cwd(), "plugins");
+    if (await fs3.pathExists(pluginsDir)) {
+      const plugins = await fs3.readdir(pluginsDir);
+      for (const plugin of plugins) {
+        const pluginJson = path3.join(pluginsDir, plugin, "plugin.json");
+        if (await fs3.pathExists(pluginJson)) {
+          const info = await fs3.readJson(pluginJson);
+          const update = await checkPackageUpdate(plugin, info.version, "plugin");
+          if (update) {
+            updates.push(update);
+          }
+        }
+      }
+    }
+  } catch (error) {
+  }
+  try {
+    const themesDir = path3.join(process.cwd(), "themes");
+    if (await fs3.pathExists(themesDir)) {
+      const themes = await fs3.readdir(themesDir);
+      for (const theme of themes) {
+        const themeJson = path3.join(themesDir, theme, "theme.json");
+        if (await fs3.pathExists(themeJson)) {
+          const info = await fs3.readJson(themeJson);
+          const update = await checkPackageUpdate(theme, info.version, "theme");
+          if (update) {
+            updates.push(update);
+          }
+        }
+      }
+    }
+  } catch (error) {
+  }
+  return updates;
+}
+async function checkCoreUpdate() {
+  try {
+    const response = await axios2.get(`${MARKETPLACE_API2}/core/latest`);
+    const latest = response.data.data;
+    const currentVersion = await getCurrentCoreVersion();
+    if (currentVersion !== latest.version) {
+      return {
+        name: "ExilonCMS Core",
+        currentVersion,
+        latestVersion: latest.version,
+        type: "core"
+      };
+    }
+  } catch (error) {
+  }
+  return null;
+}
+async function checkPackageUpdate(name, currentVersion, type) {
+  try {
+    const response = await axios2.get(`${MARKETPLACE_API2}/packages/${name}`);
+    const latest = response.data.data;
+    if (currentVersion !== latest.version) {
+      return {
+        name,
+        currentVersion,
+        latestVersion: latest.version,
+        type
+      };
+    }
+  } catch (error) {
+  }
+  return null;
+}
+async function getCurrentCoreVersion() {
+  try {
+    const composerJson = await fs3.readJson(path3.join(process.cwd(), "composer.json"));
+    const packageJson = await fs3.readJson(path3.join(process.cwd(), "package.json"));
+    return packageJson.version || "0.0.0";
+  } catch (error) {
+    return "0.0.0";
+  }
+}
+async function installUpdates(updates) {
+  for (const update of updates) {
+    const tasks = new Listr3([
+      {
+        title: `Updating ${update.name}`,
+        task: async () => {
+          if (update.type === "core") {
+            await updateCore(update);
+          } else {
+            await updatePackage(update);
+          }
+        }
+      }
+    ]);
+    await tasks.run();
+  }
+}
+async function updateCore(update) {
+  try {
+    await execa3("git", ["pull", "origin", "main"], { cwd: process.cwd() });
+    await execa3("composer", ["install"], { cwd: process.cwd() });
+    await execa3("npm", ["install"], { cwd: process.cwd() });
+    await execa3("php", ["artisan", "migrate", "--force"], { cwd: process.cwd() });
+  } catch (error) {
+    throw new Error("Failed to update core. Make sure you have git installed.");
+  }
+}
+async function updatePackage(update) {
+  const packageDir = update.type === "plugin" ? path3.join(process.cwd(), "plugins", update.name) : path3.join(process.cwd(), "themes", update.name);
+  if (!await fs3.pathExists(packageDir)) {
+    throw new Error(`${update.name} is not installed`);
+  }
+  console.log(chalk3.yellow(`Please update ${update.name} manually or reinstall from marketplace`));
+}
+
+// src/commands/list.ts
+import { select as select3 } from "@clack/prompts";
+import chalk4 from "chalk";
+import fs4 from "fs-extra";
+import path4 from "path";
+async function listCommand() {
+  try {
+    const packages = await getInstalledPackages();
+    if (packages.length === 0) {
+      console.log(chalk4.yellow("No plugins or themes installed"));
+      return;
+    }
+    const filter = await select3({
+      message: "Show:",
+      options: [
+        { value: "all", label: "\u{1F4E6} All Packages" },
+        { value: "plugins", label: "\u{1F50C} Plugins Only" },
+        { value: "themes", label: "\u{1F3A8} Themes Only" }
+      ],
+      initialValue: "all"
+    });
+    if (typeof filter !== "string") {
+      return;
+    }
+    const filtered = filter === "all" ? packages : packages.filter((p) => p.type === (filter === "plugins" ? "plugin" : "theme"));
+    console.log(chalk4.cyan("\n\u{1F4E6} Installed Packages:"));
+    console.log(chalk4.gray("\u2500".repeat(70)));
+    const plugins = filtered.filter((p) => p.type === "plugin");
+    const themes = filtered.filter((p) => p.type === "theme");
+    if (plugins.length > 0 && (filter === "all" || filter === "plugins")) {
+      console.log(chalk4.bold("\n\u{1F50C} Plugins:"));
+      plugins.forEach((pkg) => {
+        const status = pkg.enabled ? chalk4.green("\u2713 Enabled") : chalk4.gray("\u2717 Disabled");
+        console.log(`
+  ${chalk4.bold(pkg.name)} ${status}`);
+        console.log(`  ${chalk4.gray("Version:")} ${pkg.version}`);
+        console.log(`  ${chalk4.gray("Description:")} ${pkg.description}`);
+        console.log(`  ${chalk4.gray("Author:")} ${pkg.author}`);
+      });
+    }
+    if (themes.length > 0 && (filter === "all" || filter === "themes")) {
+      console.log(chalk4.bold("\n\u{1F3A8} Themes:"));
+      themes.forEach((pkg) => {
+        const active = pkg.enabled ? chalk4.green("\u2713 Active") : chalk4.gray("\u2717 Inactive");
+        console.log(`
+  ${chalk4.bold(pkg.name)} ${active}`);
+        console.log(`  ${chalk4.gray("Version:")} ${pkg.version}`);
+        console.log(`  ${chalk4.gray("Description:")} ${pkg.description}`);
+        console.log(`  ${chalk4.gray("Author:")} ${pkg.author}`);
+      });
+    }
+    console.log(chalk4.gray("\n" + "\u2500".repeat(70)));
+    console.log(chalk4.gray(`Total: ${filtered.length} package(s)`));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk4.red("Error:"), error.message);
+    }
+  }
+}
+async function getInstalledPackages() {
+  const packages = [];
+  const pluginsDir = path4.join(process.cwd(), "plugins");
+  if (await fs4.pathExists(pluginsDir)) {
+    const plugins = await fs4.readdir(pluginsDir);
+    for (const plugin of plugins) {
+      const pluginJson = path4.join(pluginsDir, plugin, "plugin.json");
+      if (await fs4.pathExists(pluginJson)) {
+        try {
+          const info = await fs4.readJson(pluginJson);
+          packages.push({
+            name: info.name || plugin,
+            version: info.version || "unknown",
+            description: info.description || "",
+            author: info.author || "Unknown",
+            type: "plugin",
+            enabled: true
+            // Would check from database
+          });
+        } catch (error) {
+        }
+      }
+    }
+  }
+  const themesDir = path4.join(process.cwd(), "themes");
+  if (await fs4.pathExists(themesDir)) {
+    const themes = await fs4.readdir(themesDir);
+    for (const theme of themes) {
+      const themeJson = path4.join(themesDir, theme, "theme.json");
+      if (await fs4.pathExists(themeJson)) {
+        try {
+          const info = await fs4.readJson(themeJson);
+          packages.push({
+            name: info.name || theme,
+            version: info.version || "unknown",
+            description: info.description || "",
+            author: info.author || "Unknown",
+            type: "theme",
+            enabled: false
+            // Would check from database
+          });
+        } catch (error) {
+        }
+      }
+    }
+  }
+  return packages;
+}
+
+// src/commands/build.ts
+import chalk5 from "chalk";
+import fs5 from "fs-extra";
+import path5 from "path";
+import { execa as execa4 } from "execa";
+import archiver from "archiver";
+import { Listr as Listr4 } from "listr2";
+async function buildCommand(options) {
+  try {
+    const packageType = await detectPackageType();
+    if (!packageType) {
+      console.log(chalk5.yellow("Not a valid plugin or theme directory"));
+      console.log(chalk5.gray("Run this command from within a plugin/theme directory"));
+      return;
+    }
+    const packageInfo = await getPackageInfo2();
+    if (!packageInfo) {
+      console.log(chalk5.yellow("Could not find package.json or plugin.json/theme.json"));
+      return;
+    }
+    console.log(chalk5.cyan(`
+\u{1F528} Building ${packageType}: ${packageInfo.name}`));
+    console.log(chalk5.gray(`Version: ${packageInfo.version}`));
+    console.log();
+    const tasks = new Listr4([
+      {
+        title: "Installing dependencies",
+        task: async () => {
+          const packageJsonPath = path5.join(process.cwd(), "package.json");
+          if (await fs5.pathExists(packageJsonPath)) {
+            await execa4("npm", ["install"], { cwd: process.cwd() });
+          } else {
+            return "Skipped (no package.json)";
+          }
+        }
+      },
+      {
+        title: "Building assets",
+        task: async () => {
+          const packageJsonPath = path5.join(process.cwd(), "package.json");
+          if (await fs5.pathExists(packageJsonPath)) {
+            const packageJson = await fs5.readJson(packageJsonPath);
+            if (packageJson.scripts?.build) {
+              await execa4("npm", ["run", "build"], { cwd: process.cwd() });
+            } else {
+              return "Skipped (no build script)";
+            }
+          } else {
+            return "Skipped (no package.json)";
+          }
+        }
+      },
+      {
+        title: "Creating distribution package",
+        task: async () => {
+          await createDistPackage(packageInfo, packageType, options.format);
+        }
+      }
+    ]);
+    await tasks.run();
+    console.log(chalk5.green("\n\u2713 Build complete!"));
+    console.log(chalk5.gray(`Package created: dist/${packageInfo.name}-${packageInfo.version}.${options.format}`));
+  } catch (error) {
+    if (error instanceof Error && error.message !== "Operation cancelled") {
+      console.error(chalk5.red("Error:"), error.message);
+    }
+  }
+}
+async function detectPackageType() {
+  const pluginJson = path5.join(process.cwd(), "plugin.json");
+  const themeJson = path5.join(process.cwd(), "theme.json");
+  if (await fs5.pathExists(pluginJson)) {
+    return "plugin";
+  }
+  if (await fs5.pathExists(themeJson)) {
+    return "theme";
+  }
+  return null;
+}
+async function getPackageInfo2() {
+  const pluginJson = path5.join(process.cwd(), "plugin.json");
+  const themeJson = path5.join(process.cwd(), "theme.json");
+  const packageJson = path5.join(process.cwd(), "package.json");
+  let info = {};
+  if (await fs5.pathExists(pluginJson)) {
+    info = { ...info, ...await fs5.readJson(pluginJson) };
+  }
+  if (await fs5.pathExists(themeJson)) {
+    info = { ...info, ...await fs5.readJson(themeJson) };
+  }
+  if (await fs5.pathExists(packageJson)) {
+    const pkg = await fs5.readJson(packageJson);
+    info = {
+      ...info,
+      name: info.name || pkg.name,
+      version: info.version || pkg.version,
+      description: info.description || pkg.description,
+      author: info.author || pkg.author
+    };
+  }
+  if (!info.name || !info.version) {
+    return null;
+  }
+  return info;
+}
+async function createDistPackage(packageInfo, packageType, format) {
+  await fs5.ensureDir(path5.join(process.cwd(), "dist"));
+  const outputFileName = `${packageInfo.name}-${packageInfo.version}.${format}`;
+  const outputPath = path5.join(process.cwd(), "dist", outputFileName);
+  const exclude = [
+    "node_modules",
+    "dist",
+    ".git",
+    ".gitignore",
+    "coverage",
+    ".env",
+    ".env.local",
+    "*.log",
+    ".DS_Store",
+    "Thumbs.db"
+  ];
+  if (format === "zip") {
+    await createZip(outputPath, exclude);
+  } else {
+    await createTar(outputPath, exclude);
+  }
+}
+async function createZip(outputPath, exclude) {
+  return new Promise((resolve, reject) => {
+    const output = fs5.createWriteStream(outputPath);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    output.on("close", () => resolve(null));
+    archive.on("error", (err) => reject(err));
+    archive.pipe(output);
+    const rootPath = process.cwd();
+    archive.directory(rootPath, false, {
+      filter: (entry) => {
+        const relativePath = path5.relative(rootPath, entry.path);
+        const parts = relativePath.split(path5.sep);
+        for (const excluded of exclude) {
+          if (parts.some((p) => p === excluded.replace("*", ""))) {
+            return false;
+          }
+          if (relativePath.startsWith(excluded)) {
+            return false;
+          }
+        }
+        return true;
+      }
+    });
+    archive.finalize();
+  });
+}
+async function createTar(outputPath, exclude) {
+  try {
+    const excludeArgs = exclude.flatMap((e) => ["--exclude", e]);
+    await execa4("tar", [
+      "-czf",
+      outputPath,
+      ...excludeArgs,
+      "."
+    ], { cwd: process.cwd() });
+  } catch (error) {
+    throw new Error("tar command not available. Please use --format zip instead.");
+  }
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+function showBanner() {
+  const banner = gradient("cyan", "magenta")(`
+ \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+ \u2551                                                   \u2551
+ \u2551   \u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557  \u2551
+ \u2551   \u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2588\u2588\u2557\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551  \u2551
+ \u2551   \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557   \u255A\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551  \u2551
+ \u2551   \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D   \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551  \u2551
+ \u2551   \u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2554\u255D \u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551  \u2551
+ \u2551   \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D  \u2551
+ \u2551                                                   \u2551
+ \u2551              Developer CLI v${VERSION}               \u2551
+ \u2551                                                   \u2551
+ \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+  console.log(banner);
+}
+var program = new Command();
+program.name("exiloncms").description(chalk6.cyan("ExilonCMS Developer CLI - Create plugins and themes with ease")).version(VERSION);
+program.command("new").description("Create a new plugin or theme").argument("[type]", "Type of project (plugin or theme)").action(async (type) => {
+  intro(chalk6.cyan("\u{1F680} ExilonCMS CLI"));
+  showBanner();
+  await newCommand(type);
+  outro(chalk6.green("\u2713 Done!"));
+});
+program.command("install").description("Install a plugin or theme from marketplace").argument("[name]", "Package name").action(async (name) => {
+  intro(chalk6.cyan("\u{1F4E6} ExilonCMS Package Manager"));
+  showBanner();
+  await installCommand(name);
+  outro(chalk6.green("\u2713 Package installed!"));
+});
+program.command("update").description("Update ExilonCMS core or packages").option("--core", "Update CMS core only").option("--packages", "Update installed packages only").action(async (options) => {
+  intro(chalk6.cyan("\u{1F504} ExilonCMS Updater"));
+  showBanner();
+  await updateCommand(options);
+  outro(chalk6.green("\u2713 Update complete!"));
+});
+program.command("list").description("List installed plugins and themes").action(async () => {
+  intro(chalk6.cyan("\u{1F4CB} ExilonCMS Packages"));
+  showBanner();
+  await listCommand();
+});
+program.command("build").description("Build a plugin or theme for distribution").option("--format <format>", "Output format (zip|tar)", "zip").action(async (options) => {
+  intro(chalk6.cyan("\u{1F528} ExilonCMS Builder"));
+  showBanner();
+  await buildCommand(options);
+  outro(chalk6.green("\u2713 Build complete!"));
+});
+program.parse();
+if (!process.argv.slice(2).length) {
+  intro(chalk6.cyan("\u{1F680} ExilonCMS CLI"));
+  showBanner();
+  program.outputHelp();
+  outro(chalk6.gray('Tip: Run "exiloncms new" to create a new plugin or theme'));
+}
+//# sourceMappingURL=index.js.map