@lytjs/cli 5.0.4 → 6.4.0

package/dist/lyt.cjs

@@ -0,0 +1,1363 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var child_process = require('child_process');
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/logger.ts
+var colors = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m"
+};
+function colorize(text, color) {
+  if (!isColorSupported()) return text;
+  return `${colors[color]}${text}${colors.reset}`;
+}
+var logger = {
+  info(message) {
+    console.log(colorize("\u2139 ", "blue") + message);
+  },
+  success(message) {
+    console.log(colorize("\u2714 ", "green") + message);
+  },
+  warning(message) {
+    console.log(colorize("\u26A0 ", "yellow") + message);
+  },
+  error(message) {
+    console.error(colorize("\u2716 ", "red") + message);
+  },
+  dim(message) {
+    console.log(colorize(message, "dim"));
+  },
+  bold(message) {
+    return colorize(message, "bright");
+  }
+};
+function isColorSupported() {
+  return process.stdout.isTTY && process.env.NO_COLOR !== "1";
+}
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function writeFile(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+function readFile(filePath) {
+  return fs.readFileSync(filePath, "utf-8");
+}
+function exists(path) {
+  return fs.existsSync(path);
+}
+function isEmptyDir(dir) {
+  if (!fs.existsSync(dir)) return true;
+  const files = fs.readdirSync(dir);
+  return files.length === 0;
+}
+function detectPackageManager(cwd = process.cwd()) {
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs.existsSync(path.join(cwd, "package-lock.json"))) return "npm";
+  try {
+    child_process.execSync("pnpm --version", { stdio: "ignore" });
+    return "pnpm";
+  } catch {
+    return "npm";
+  }
+}
+function getInstallCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn";
+    case "npm":
+      return "npm install";
+  }
+}
+function getRunCommand(pm, script) {
+  switch (pm) {
+    case "pnpm":
+      return `pnpm run ${script}`;
+    case "yarn":
+      return `yarn ${script}`;
+    case "npm":
+      return `npm run ${script}`;
+  }
+}
+function getAddCommand(pm, dep, dev2 = false) {
+  const devFlag = dev2 ? " -D" : "";
+  switch (pm) {
+    case "pnpm":
+      return `pnpm add${devFlag} ${dep}`;
+    case "yarn":
+      return `yarn add${devFlag} ${dep}`;
+    case "npm":
+      return `npm install${devFlag} ${dep}`;
+  }
+}
+var TEMPLATES = {
+  default: "Default template with TypeScript and Vite",
+  minimal: "Minimal template without extra dependencies",
+  ssr: "SSR-enabled template",
+  router: "Template with Router integration",
+  store: "Template with Store integration",
+  full: "Full-featured template with Router, Store, and UI components"
+};
+async function create(projectName, options = {}) {
+  if (!projectName) {
+    logger.error("Please provide a project name.");
+    logger.info("Usage: lyt create <project-name>");
+    process.exit(1);
+  }
+  const targetDir = path.resolve(process.cwd(), projectName);
+  if (exists(targetDir) && !isEmptyDir(targetDir) && !options.force) {
+    logger.error(`Directory "${projectName}" already exists and is not empty.`);
+    logger.info("Use --force to overwrite.");
+    process.exit(1);
+  }
+  logger.info(`Creating a new LytJS project in ${targetDir}...`);
+  ensureDir(targetDir);
+  generateProjectFiles(targetDir, projectName, options.template || "default");
+  logger.info("Installing dependencies...");
+  const pm = detectPackageManager();
+  try {
+    child_process.execSync(getInstallCommand(pm), { cwd: targetDir, stdio: "inherit" });
+    logger.success("Dependencies installed successfully!");
+  } catch (_error) {
+    logger.warning("Failed to install dependencies automatically.");
+    logger.info(`Please run "${getInstallCommand(pm)}" manually.`);
+  }
+  logger.success(`Project "${projectName}" created successfully!`);
+  logger.info("");
+  logger.bold("Next steps:");
+  logger.info(`  cd ${projectName}`);
+  logger.info(`  ${pm === "npm" ? "npm run" : pm} dev`);
+}
+function generateProjectFiles(targetDir, projectName, template) {
+  const isMinimal = template === "minimal";
+  const isSsr = template === "ssr";
+  const isRouter = template === "router" || template === "full";
+  const isStore = template === "store" || template === "full";
+  const isFull = template === "full";
+  const packageJson = {
+    name: projectName,
+    version: "0.0.0",
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview"
+    },
+    dependencies: {
+      "@lytjs/core": "^6.0.0"
+    },
+    devDependencies: {
+      "@lytjs/plugin-vite": "^6.0.0",
+      "vite": "^5.0.0"
+    }
+  };
+  if (!isMinimal) {
+    packageJson.scripts.test = "vitest";
+    packageJson.devDependencies.vitest = "^1.0.0";
+  }
+  if (isSsr) {
+    packageJson.dependencies["@lytjs/server"] = "^6.0.0";
+    packageJson.scripts["build:client"] = "vite build --ssrManifest";
+    packageJson.scripts["build:server"] = "vite build --ssr src/entry-server.ts";
+    packageJson.scripts["build"] = "npm run build:client && npm run build:server";
+    packageJson.scripts["preview"] = "node server";
+  }
+  if (isRouter) {
+    packageJson.dependencies["@lytjs/router"] = "^1.0.0";
+  }
+  if (isStore) {
+    packageJson.dependencies["@lytjs/store"] = "^1.0.0";
+  }
+  if (isFull) {
+    packageJson.dependencies["@lytjs/ui"] = "^0.4.0";
+  }
+  writeFile(path.join(targetDir, "package.json"), JSON.stringify(packageJson, null, 2));
+  let viteConfig;
+  if (isSsr) {
+    viteConfig = `import { defineConfig } from 'vite';
+import lytjs from '@lytjs/plugin-vite';
+
+export default defineConfig({
+  plugins: [lytjs()],
+  build: {
+    ssrManifest: true,
+  },
+});
+`;
+  } else {
+    viteConfig = `import { defineConfig } from 'vite';
+import lytjs from '@lytjs/plugin-vite';
+
+export default defineConfig({
+  plugins: [lytjs()],
+});
+`;
+  }
+  writeFile(path.join(targetDir, "vite.config.ts"), viteConfig);
+  const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${projectName}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`;
+  writeFile(path.join(targetDir, "index.html"), indexHtml);
+  let mainTs;
+  if (isSsr) {
+    mainTs = `import { createApp } from '@lytjs/core';
+import App from './App.lyt';
+import { createSSRApp } from '@lytjs/server';
+${isRouter ? "import { createRouter, createWebHistory } from '@lytjs/router';" : ""}
+${isStore ? "import { createPinia } from '@lytjs/store';" : ""}
+
+const app = createSSRApp(App);
+${isStore ? "app.use(createPinia());" : ""}
+${isRouter ? `
+const router = createRouter({
+  history: createWebHistory(),
+  routes: [
+    { path: '/', component: () => import('./pages/Home.lyt') },
+    { path: '/about', component: () => import('./pages/About.lyt') },
+  ],
+});
+app.use(router);
+` : ""}
+app.mount('#app');
+`;
+  } else if (isRouter || isStore) {
+    mainTs = `import { createApp } from '@lytjs/core';
+import App from './App.lyt';
+${isRouter ? "import { createRouter, createWebHistory } from '@lytjs/router';" : ""}
+${isStore ? "import { createPinia } from '@lytjs/store';" : ""}
+
+const app = createApp(App);
+${isStore ? "app.use(createPinia());" : ""}
+${isRouter ? `
+const router = createRouter({
+  history: createWebHistory(),
+  routes: [
+    { path: '/', component: () => import('./pages/Home.lyt') },
+    { path: '/about', component: () => import('./pages/About.lyt') },
+  ],
+});
+app.use(router);
+` : ""}
+app.mount('#app');
+`;
+  } else {
+    mainTs = `import { createApp } from '@lytjs/core';
+import App from './App.lyt';
+
+createApp(App).mount('#app');
+`;
+  }
+  writeFile(path.join(targetDir, "src/main.ts"), mainTs);
+  let appLyt;
+  if (isMinimal) {
+    appLyt = `<template>
+  <div class="app">
+    <h1>{{ title }}</h1>
+  </div>
+</template>
+
+<script setup>
+const title = 'Hello LytJS!';
+</script>
+
+<style scoped>
+.app {
+  text-align: center;
+}
+</style>
+`;
+  } else if (isRouter) {
+    appLyt = `<template>
+  <div class="app">
+    <nav class="nav">
+      <router-link to="/">Home</router-link>
+      <router-link to="/about">About</router-link>
+    </nav>
+    <router-view />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { RouterLink, RouterView } from '@lytjs/router';
+</script>
+
+<style scoped>
+.app {
+  text-align: center;
+  padding: 2rem;
+}
+
+.nav {
+  margin-bottom: 2rem;
+}
+
+.nav a {
+  margin: 0 1rem;
+  color: #42b883;
+  text-decoration: none;
+}
+
+.nav a:hover {
+  text-decoration: underline;
+}
+</style>
+`;
+  } else {
+    appLyt = `<template>
+  <div class="app">
+    <h1>{{ title }}</h1>
+    <p>Welcome to your LytJS app!</p>
+  </div>
+</template>
+
+<script setup>
+const title = 'Hello LytJS!';
+</script>
+
+<style scoped>
+.app {
+  text-align: center;
+  padding: 2rem;
+}
+
+h1 {
+  color: #42b883;
+}
+</style>
+`;
+  }
+  writeFile(path.join(targetDir, "src/App.lyt"), appLyt);
+  if (isRouter) {
+    const homePage = `<template>
+  <div class="home">
+    <h1>Home</h1>
+    ${isStore ? `
+    <p>Count: {{ count }}</p>
+    <button @click="increment">Increment</button>
+    <button @click="decrement">Decrement</button>
+    ` : ""}
+    <p>Welcome to the Home page!</p>
+  </div>
+</template>
+
+<script setup lang="ts">
+${isStore ? `import { useCounterStore } from '../stores/counter';
+const counterStore = useCounterStore();
+const { count, increment, decrement } = counterStore;
+` : ""}
+</script>
+
+<style scoped>
+.home {
+  padding: 1rem;
+}
+</style>
+`;
+    ensureDir(path.join(targetDir, "src", "pages"));
+    writeFile(path.join(targetDir, "src", "pages", "Home.lyt"), homePage);
+    const aboutPage = `<template>
+  <div class="about">
+    <h1>About</h1>
+    <p>This is the About page!</p>
+  </div>
+</template>
+
+<script setup lang="ts">
+</script>
+
+<style scoped>
+.about {
+  padding: 1rem;
+}
+</style>
+`;
+    writeFile(path.join(targetDir, "src", "pages", "About.lyt"), aboutPage);
+  }
+  if (isStore) {
+    const counterStore = `import { defineStore } from '@lytjs/store';
+import { signal, computed } from '@lytjs/reactivity';
+
+export const useCounterStore = defineStore('counter', () => {
+  // State
+  const count = signal(0);
+
+  // Getters
+  const doubleCount = computed(() => count.value * 2);
+
+  // Actions
+  function increment() {
+    count.value++;
+  }
+
+  function decrement() {
+    count.value--;
+  }
+
+  function reset() {
+    count.value = 0;
+  }
+
+  return {
+    count,
+    doubleCount,
+    increment,
+    decrement,
+    reset,
+  };
+});
+`;
+    ensureDir(path.join(targetDir, "src", "stores"));
+    writeFile(path.join(targetDir, "src", "stores", "counter.ts"), counterStore);
+  }
+  if (isSsr) {
+    const entryServer = `import { createSSRApp } from '@lytjs/core';
+import App from './App.lyt';
+
+export async function render(url: string) {
+  const app = createSSRApp(App);
+  return app;
+}
+`;
+    writeFile(path.join(targetDir, "src/entry-server.ts"), entryServer);
+    const entryClient = `import { createApp } from '@lytjs/core';
+import App from './App.lyt';
+
+const app = createApp(App);
+app.mount('#app');
+`;
+    writeFile(path.join(targetDir, "src/entry-client.ts"), entryClient);
+    const serverTs = `/**
+ * LytJS SSR Server
+ *
+ * A minimal SSR server for development and production.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const isProduction = process.env.NODE_ENV === 'production';
+
+async function createServer() {
+  let resolve: any;
+  let vite: any;
+
+  if (!isProduction) {
+    const { createServer: createViteServer } = await import('vite');
+    vite = await createViteServer({
+      server: { middlewareMode: true },
+      appType: 'custom',
+    });
+    resolve = (id: string) => vite.resolveUrl(id);
+  } else {
+    resolve = (id: string) => id;
+  }
+
+  // TODO: Set up express/polka server and SSR rendering
+  console.log('LytJS SSR server starting...');
+}
+
+createServer();
+`;
+    writeFile(path.join(targetDir, "server.ts"), serverTs);
+  }
+  const tsConfig = {
+    compilerOptions: {
+      target: "ES2020",
+      useDefineForClassFields: true,
+      module: "ESNext",
+      lib: ["ES2020", "DOM", "DOM.Iterable"],
+      skipLibCheck: true,
+      moduleResolution: "bundler",
+      allowImportingTsExtensions: true,
+      resolveJsonModule: true,
+      isolatedModules: true,
+      noEmit: true,
+      strict: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      noFallthroughCasesInSwitch: true
+    },
+    include: ["src/**/*.ts", "src/**/*.lyt"],
+    references: [{ path: "./tsconfig.node.json" }]
+  };
+  writeFile(path.join(targetDir, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
+  const tsConfigNode = {
+    compilerOptions: {
+      composite: true,
+      skipLibCheck: true,
+      module: "ESNext",
+      moduleResolution: "bundler",
+      allowSyntheticDefaultImports: true
+    },
+    include: ["vite.config.ts"]
+  };
+  writeFile(path.join(targetDir, "tsconfig.node.json"), JSON.stringify(tsConfigNode, null, 2));
+  const gitignore = `# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+`;
+  writeFile(path.join(targetDir, ".gitignore"), gitignore);
+}
+function listTemplates() {
+  logger.bold("Available templates:");
+  for (const [name, description] of Object.entries(TEMPLATES)) {
+    logger.info(`  ${name.padEnd(10)} - ${description}`);
+  }
+}
+async function dev(options = {}) {
+  if (!exists(path.join(process.cwd(), "package.json"))) {
+    logger.error("No package.json found. Are you in a LytJS project directory?");
+    process.exit(1);
+  }
+  const pm = detectPackageManager();
+  const runCmd = getRunCommand(pm, "dev");
+  logger.info(`Starting development server with ${pm}...`);
+  const devArgs = [];
+  if (options.port) devArgs.push("--port", String(options.port));
+  if (options.host) devArgs.push("--host", options.host);
+  if (options.open) devArgs.push("--open");
+  const cmdParts = runCmd.split(" ");
+  const cmd = cmdParts[0] ?? "pnpm";
+  const cmdArgs = [...cmdParts.slice(1), ...devArgs];
+  const child = child_process.spawn(cmd, cmdArgs, {
+    stdio: "inherit",
+    shell: true
+  });
+  child.on("error", (error) => {
+    logger.error(`Failed to start dev server: ${error.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    process.exit(code || 0);
+  });
+}
+async function build(options = {}) {
+  if (!exists(path.join(process.cwd(), "package.json"))) {
+    logger.error("No package.json found. Are you in a LytJS project directory?");
+    process.exit(1);
+  }
+  const pm = detectPackageManager();
+  logger.info("Building for production...");
+  const args = ["vite", "build"];
+  if (options.outDir) args.push("--outDir", options.outDir);
+  if (options.ssr) args.push("--ssr");
+  if (options.minify === false) args.push("--minify", "false");
+  const child = child_process.spawn(pm === "npm" ? "npx" : pm, args, {
+    stdio: "inherit",
+    shell: true
+  });
+  child.on("error", (error) => {
+    logger.error(`Build failed: ${error.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    if (code === 0) {
+      logger.success("Build completed successfully!");
+    } else {
+      logger.error(`Build failed with exit code ${code}`);
+    }
+    process.exit(code || 0);
+  });
+}
+async function test(options = {}) {
+  if (!exists(path.join(process.cwd(), "package.json"))) {
+    logger.error("No package.json found. Are you in a LytJS project directory?");
+    process.exit(1);
+  }
+  const pm = detectPackageManager();
+  logger.info("Running tests...");
+  const args = ["vitest"];
+  if (options.watch === false) args.push("run");
+  if (options.coverage) args.push("--coverage");
+  if (options.grep) args.push("--grep", options.grep);
+  const child = child_process.spawn(pm === "npm" ? "npx" : pm, args, {
+    stdio: "inherit",
+    shell: true
+  });
+  child.on("error", (error) => {
+    logger.error(`Tests failed: ${error.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    process.exit(code || 0);
+  });
+}
+var TEMPLATES2 = {
+  component(name, basePath) {
+    const filePath = path.join(basePath, `${name}.lyt`);
+    return [{
+      filePath,
+      content: `<template>
+  <div class="${name}">
+    <slot />
+  </div>
+</template>
+
+<script setup lang="ts">
+defineProps<{
+  /** Component props */
+}>();
+
+defineEmits<{
+  /** Component events */
+}>();
+</script>
+
+<style scoped>
+.${name} {
+  /* styles */
+}
+</style>
+`
+    }];
+  },
+  page(name, basePath) {
+    const filePath = path.join(basePath, `${name}.lyt`);
+    return [{
+      filePath,
+      content: `<template>
+  <div class="page-${name}">
+    <h1>${toPascalCase(name)}</h1>
+  </div>
+</template>
+
+<script setup lang="ts">
+// Page logic here
+</script>
+
+<style scoped>
+.page-${name} {
+  padding: 1rem;
+}
+</style>
+`
+    }];
+  },
+  store(name, basePath) {
+    const filePath = path.join(basePath, `${name}.ts`);
+    return [{
+      filePath,
+      content: `import { defineStore } from '@lytjs/store';
+import { signal, computed } from '@lytjs/reactivity';
+
+export const use${toPascalCase(name)}Store = defineStore('${name}', () => {
+  // State
+  const count = signal(0);
+
+  // Getters
+  const doubleCount = computed(() => count.value * 2);
+
+  // Actions
+  function increment() {
+    count.value++;
+  }
+
+  function decrement() {
+    count.value--;
+  }
+
+  function reset() {
+    count.value = 0;
+  }
+
+  return {
+    count,
+    doubleCount,
+    increment,
+    decrement,
+    reset,
+  };
+});
+`
+    }];
+  }
+};
+function toPascalCase(str) {
+  return str.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function resolveTargetDir(type) {
+  const cwd = process.cwd();
+  switch (type) {
+    case "component":
+      return path.join(cwd, "src", "components");
+    case "page":
+      return path.join(cwd, "src", "pages");
+    case "store":
+      return path.join(cwd, "src", "stores");
+  }
+}
+async function add(type, name, options = {}) {
+  const targetDir = resolveTargetDir(type);
+  const fullPath = path.resolve(targetDir);
+  if (!exists(path.join(process.cwd(), "package.json"))) {
+    logger.error("No package.json found. Are you in a LytJS project directory?");
+    process.exit(1);
+  }
+  const template = TEMPLATES2[type];
+  if (!template) {
+    logger.error(`Unknown type: ${type}. Supported types: component, page, store`);
+    process.exit(1);
+  }
+  const files = template(name, fullPath);
+  for (const file of files) {
+    if (exists(file.filePath) && !options.force) {
+      logger.warning(`File already exists: ${file.filePath}`);
+      logger.info("Use --force to overwrite.");
+      continue;
+    }
+    ensureDir(path.resolve(file.filePath, ".."));
+    writeFile(file.filePath, file.content);
+    logger.success(`Created ${type}: ${file.filePath}`);
+  }
+}
+var PLUGIN_TEMPLATES = {
+  default: "Default plugin template with TypeScript",
+  minimal: "Minimal plugin without extra dependencies",
+  withConfig: "Plugin template with configuration schema"
+};
+function getTemplateContent(template, pluginName) {
+  const packageName = `@lytjs/plugin-${pluginName}`;
+  const files = {};
+  files["package.json"] = JSON.stringify({
+    name: packageName,
+    version: "0.1.0",
+    description: `LytJS plugin: ${pluginName}`,
+    main: "dist/index.cjs",
+    module: "dist/index.mjs",
+    types: "dist/index.d.ts",
+    exports: {
+      ".": {
+        import: "./dist/index.mjs",
+        require: "./dist/index.cjs",
+        types: "./dist/index.d.ts"
+      }
+    },
+    files: ["dist"],
+    scripts: {
+      build: "tsup",
+      dev: "tsup --watch",
+      test: "vitest",
+      lint: "eslint src",
+      "prepublishOnly": "npm run build"
+    },
+    keywords: ["lytjs", "plugin"],
+    license: "MIT",
+    peerDependencies: {
+      "@lytjs/core": ">=6.0.0"
+    }
+  }, null, 2);
+  files["tsconfig.json"] = JSON.stringify({
+    extends: "@lytjs/core/tsconfig.json",
+    compilerOptions: {
+      outDir: "./dist",
+      rootDir: "./src",
+      declaration: true,
+      declarationMap: true
+    },
+    include: ["src"],
+    exclude: ["node_modules", "dist", "tests"]
+  }, null, 2);
+  files["tsup.config.ts"] = `import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: { index: 'src/index.ts' },
+  format: ['esm', 'cjs'],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  splitting: false,
+  treeshake: true,
+  minify: false,
+  external: ['@lytjs/core'],
+});
+`;
+  if (template === "withConfig") {
+    files["src/index.ts"] = `/**
+ * @lytjs/plugin-${pluginName}
+ *
+ * A LytJS plugin with configuration schema support.
+ */
+
+import { definePlugin } from '@lytjs/core';
+import type { ConfigSchema } from '@lytjs/core';
+
+/**
+ * Plugin options schema
+ */
+const optionsSchema: ConfigSchema<${pluginName.replace(/-/g, "")}Options> = {
+  type: 'object',
+  properties: {
+    debug: {
+      type: 'boolean',
+      description: 'Enable debug mode',
+      default: false,
+    },
+    option1: {
+      type: 'string',
+      description: 'First option',
+      default: 'default value',
+    },
+  },
+  additionalProperties: false,
+};
+
+${pluginName.replace(/-/g, "")}Options\`;
+
+export interface ${pluginName.replace(/-/g, "")}Options {
+  debug?: boolean;
+  option1?: string;
+}
+
+/**
+ * Create the plugin with configuration schema
+ */
+export function create${pluginName.replace(/-/g, "").replace(/^\w/, (c) => c.toUpperCase())}(options?: ${pluginName.replace(/-/g, "")}Options) {
+  return definePlugin({
+    name: '${packageName}',
+    version: '0.1.0',
+    description: 'A LytJS plugin',
+    schema: optionsSchema,
+    install: (app, opts) => {
+      const config = opts || {};
+      console.log('[${packageName}] Installing with config:', config);
+    },
+  });
+}
+
+/**
+ * Direct plugin export (without schema)
+ */
+export default create${pluginName.replace(/-/g, "").replace(/^\w/, (c) => c.toUpperCase())}();
+`;
+  } else {
+    files["src/index.ts"] = `/**
+ * @lytjs/plugin-${pluginName}
+ *
+ * A LytJS plugin.
+ */
+
+import { definePlugin } from '@lytjs/core';
+
+/**
+ * Create the plugin
+ */
+export function create${pluginName.replace(/-/g, "").replace(/^\w/, (c) => c.toUpperCase())}() {
+  return definePlugin({
+    name: '${packageName}',
+    version: '0.1.0',
+    description: 'A LytJS plugin',
+    install: (app) => {
+      console.log('[${packageName}] Plugin installed');
+    },
+  });
+}
+
+/**
+ * Direct plugin export
+ */
+export default create${pluginName.replace(/-/g, "").replace(/^\w/, (c) => c.toUpperCase())}();
+`;
+  }
+  if (template === "minimal") {
+    files["src/types.ts"] = `/**
+ * Plugin types
+ */
+
+export interface PluginOptions {
+  // Define your plugin options here
+}
+`;
+  }
+  files["README.md"] = `# @lytjs/plugin-${pluginName}
+
+A LytJS plugin.
+
+## Installation
+
+\`\`\`bash
+npm install @lytjs/plugin-${pluginName}
+\`\`\`
+
+## Usage
+
+\`\`\`typescript
+import { createApp } from '@lytjs/core';
+import myPlugin from '@lytjs/plugin-${pluginName}';
+
+const app = createApp(App);
+app.use(myPlugin);
+\`\`\`
+
+## API
+
+### createPlugin(options?)
+
+Create the plugin with options.
+
+## License
+
+MIT
+`;
+  files[".gitignore"] = `# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+pnpm-debug.log*
+
+node_modules
+dist
+*.local
+
+# IDE
+.vscode
+.idea
+*.sw?
+`;
+  return files;
+}
+async function createPlugin(name, options = {}) {
+  const targetDir = path.resolve(process.cwd(), name);
+  const template = options.template || "default";
+  if (template !== "default" && template !== "minimal" && template !== "withConfig") {
+    logger.error(`Unknown template: ${template}`);
+    logger.info("Available templates: default, minimal, withConfig");
+    process.exit(1);
+  }
+  if (fs.existsSync(targetDir) && !isEmptyDir2(targetDir) && !options.force) {
+    logger.error(`Directory "${name}" already exists and is not empty.`);
+    logger.info("Use --force to overwrite.");
+    process.exit(1);
+  }
+  logger.info(`Creating a new LytJS plugin in ${targetDir}...`);
+  ensureDir(targetDir);
+  const files = getTemplateContent(template, name);
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = path.join(targetDir, filePath);
+    const fileDir = path.resolve(fullPath, "..");
+    if (!fs.existsSync(fileDir)) {
+      fs.mkdirSync(fileDir, { recursive: true });
+    }
+    fs.writeFileSync(fullPath, content, "utf-8");
+    logger.success(`Created: ${filePath}`);
+  }
+  if (!options.skipInstall) {
+    logger.info("Installing dependencies...");
+    try {
+      child_process.execSync("pnpm install", { cwd: targetDir, stdio: "inherit" });
+      logger.success("Dependencies installed!");
+    } catch (_error) {
+      logger.warning("Failed to install dependencies automatically.");
+      logger.info('Please run "pnpm install" manually.');
+    }
+  }
+  logger.success(`Plugin "${name}" created successfully!`);
+  logger.info("");
+  logger.bold("Next steps:");
+  logger.info(`  cd ${name}`);
+  logger.info("  pnpm dev      # Start development");
+  logger.info("  pnpm build    # Build for production");
+  logger.info("  pnpm test     # Run tests");
+}
+async function buildPlugin(options = {}) {
+  const cwd = process.cwd();
+  const outDir = options.outDir || "dist";
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    logger.error("No package.json found. Are you in a plugin directory?");
+    process.exit(1);
+  }
+  logger.info("Building plugin...");
+  try {
+    const buildCmd = "tsup";
+    const args = ["--entry", "src/index.ts", "--outDir", outDir, "--format", "esm,cjs", "--dts", "--sourcemap"];
+    if (options.minify) {
+      args.push("--minify");
+    }
+    child_process.execSync(`${buildCmd} ${args.join(" ")}`, { cwd, stdio: "inherit" });
+    logger.success("Build completed!");
+    logger.info(`Output: ${path.join(cwd, outDir)}`);
+  } catch (_error) {
+    logger.error("Build failed. Make sure tsup is installed: pnpm add -D tsup");
+    process.exit(1);
+  }
+}
+async function validatePlugin(options = {}) {
+  const cwd = process.cwd();
+  logger.info("Validating plugin...");
+  const errors = [];
+  const warnings = [];
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    errors.push("package.json not found");
+  } else {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      if (!pkg.name) errors.push("package.json: name is required");
+      if (!pkg.version) errors.push("package.json: version is required");
+      if (!pkg.main) errors.push("package.json: main is required");
+      if (!pkg.module) errors.push("package.json: module is required");
+      if (!pkg.types) errors.push("package.json: types is required");
+      if (!pkg.exports) {
+        warnings.push("package.json: exports field is recommended");
+      }
+      if (!pkg.peerDependencies || !pkg.peerDependencies["@lytjs/core"]) {
+        errors.push("package.json: @lytjs/core peerDependency is required");
+      }
+      if (!pkg.keywords || !pkg.keywords.includes("lytjs")) {
+        warnings.push('package.json: "lytjs" keyword is recommended');
+      }
+    } catch (err) {
+      errors.push(`package.json: Invalid JSON - ${err}`);
+    }
+  }
+  const srcPath = path.join(cwd, "src");
+  if (!fs.existsSync(srcPath)) {
+    errors.push("src directory not found");
+  } else {
+    const indexPath = path.join(srcPath, "index.ts");
+    if (!fs.existsSync(indexPath)) {
+      errors.push("src/index.ts not found");
+    } else {
+      const content = fs.readFileSync(indexPath, "utf-8");
+      if (!content.includes("definePlugin") && !content.includes("EnhancedPlugin")) {
+        warnings.push("src/index.ts: Consider using definePlugin or EnhancedPlugin");
+      }
+      if (!content.includes("export")) {
+        warnings.push("src/index.ts: No exports found");
+      }
+    }
+  }
+  const tsconfigPath = path.join(cwd, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) {
+    warnings.push("tsconfig.json not found (recommended)");
+  }
+  const tsupConfigPath = path.join(cwd, "tsup.config.ts");
+  if (!fs.existsSync(tsupConfigPath)) {
+    warnings.push("tsup.config.ts not found (recommended for builds)");
+  }
+  let hasErrors = errors.length > 0;
+  let hasWarnings = warnings.length > 0;
+  if (hasErrors) {
+    logger.error("Validation failed with errors:");
+    for (const err of errors) {
+      logger.error(`  - ${err}`);
+    }
+  }
+  if (hasWarnings && !options.strict) {
+    logger.warning("Warnings:");
+    for (const warn of warnings) {
+      logger.warning(`  - ${warn}`);
+    }
+  }
+  if (!hasErrors && !hasWarnings) {
+    logger.success("Plugin validation passed!");
+  } else if (hasWarnings && !hasErrors) {
+    logger.success("Plugin validation passed (with warnings)");
+    if (options.strict) {
+      process.exit(1);
+    }
+  } else {
+    if (options.warningsAsErrors && hasWarnings) {
+      logger.error("Strict mode: treating warnings as errors");
+    }
+    process.exit(1);
+  }
+}
+function isEmptyDir2(dir) {
+  if (!fs.existsSync(dir)) return true;
+  const files = __require("fs").readdirSync(dir);
+  return files.length === 0;
+}
+function listPluginTemplates() {
+  logger.bold("Available plugin templates:");
+  for (const [name, description] of Object.entries(PLUGIN_TEMPLATES)) {
+    logger.info(`  ${name.padEnd(12)} - ${description}`);
+  }
+}
+
+// src/commands/run.ts
+var VERSION = "6.0.0";
+async function runCli(rawArgs = process.argv.slice(2)) {
+  const { command, args, options } = parseArgs(rawArgs);
+  if (options.help || command === "help") {
+    showHelp();
+    return;
+  }
+  if (options.version || command === "version" || command === "-v" || command === "--version") {
+    console.log(`LytJS CLI v${VERSION}`);
+    return;
+  }
+  switch (command) {
+    case "create":
+      await create(args[0] || "my-lytjs-app", {
+        template: options.template,
+        force: options.force
+      });
+      break;
+    case "templates":
+      listTemplates();
+      break;
+    case "dev":
+      await dev({
+        port: options.port ? parseInt(options.port, 10) : void 0,
+        host: options.host,
+        open: options.open
+      });
+      break;
+    case "build":
+      await build({
+        outDir: options.outDir,
+        ssr: options.ssr,
+        minify: options.minify !== "false"
+      });
+      break;
+    case "test":
+      await test({
+        watch: options.watch !== "false",
+        coverage: options.coverage,
+        grep: options.grep
+      });
+      break;
+    case "add":
+      if (!args[0] || !["component", "page", "store"].includes(args[0])) {
+        logger.error("Usage: lyt add <component|page|store> <name>");
+        logger.info("Example: lyt add component Button");
+        process.exit(1);
+      }
+      await add(args[0], args[1] || "Unnamed", {
+        force: options.force
+      });
+      break;
+    case "plugin":
+      if (!args[0]) {
+        logger.error("Usage: lyt plugin <create|build|validate|templates>");
+        logger.info("Example: lyt plugin create my-plugin");
+        process.exit(1);
+      }
+      const subCommand = args[0];
+      switch (subCommand) {
+        case "create":
+          await createPlugin(args[1] || "my-plugin", {
+            template: options.template,
+            force: options.force,
+            skipInstall: options.skipInstall
+          });
+          break;
+        case "build":
+          await buildPlugin({
+            outDir: options.outDir,
+            minify: options.minify,
+            sourcemap: options.sourcemap
+          });
+          break;
+        case "validate":
+          await validatePlugin({
+            strict: options.strict,
+            warningsAsErrors: options.warningsAsErrors
+          });
+          break;
+        case "templates":
+          listPluginTemplates();
+          break;
+        default:
+          logger.error(`Unknown plugin sub-command: ${subCommand}`);
+          logger.info("Supported sub-commands: create, build, validate, templates");
+          process.exit(1);
+      }
+      break;
+    default:
+      if (command) {
+        logger.error(`Unknown command: ${command}`);
+        logger.info('Run "lyt --help" for usage information.');
+        process.exit(1);
+      } else {
+        showHelp();
+      }
+  }
+}
+function parseArgs(args) {
+  let command = args[0] ?? "";
+  const positional = [];
+  const options = {};
+  if (command.startsWith("--") || command.startsWith("-")) {
+    command = "";
+  }
+  const startIndex = command ? 1 : 0;
+  for (let i = startIndex; i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg.startsWith("--")) {
+      const parts = arg.slice(2).split("=");
+      const key = parts[0];
+      const value = parts[1];
+      if (value !== void 0 && key) {
+        options[key] = value;
+      } else if (key && i + 1 < args.length && !(args[i + 1] ?? "").startsWith("-")) {
+        const nextArg = args[++i];
+        if (nextArg) {
+          options[key] = nextArg;
+        }
+      } else if (key) {
+        options[key] = true;
+      }
+    } else if (arg.startsWith("-")) {
+      const key = arg.slice(1);
+      if (key) {
+        options[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { command, args: positional, options };
+}
+function showHelp() {
+  console.log(`
+${logger.bold("LytJS CLI")} v${VERSION}
+
+${logger.bold("Usage:")}
+  lyt <command> [options]
+
+${logger.bold("Commands:")}
+  create <name>            Create a new LytJS project
+  templates                List available templates
+  dev                      Start development server
+  build                    Build for production
+  test                     Run tests
+  add <type> <name>        Generate a component, page, or store
+  plugin <subcmd>          Plugin development commands
+  help                     Show this help message
+
+${logger.bold("Options:")}
+  --version, -v     Show version number
+  --help            Show help
+
+${logger.bold("Create Options:")}
+  --template <name> Use a specific template
+  --force           Overwrite existing directory
+
+${logger.bold("Dev Options:")}
+  --port <number>   Specify port (default: 5173)
+  --host <host>     Specify host (default: localhost)
+  --open            Open browser on start
+
+${logger.bold("Build Options:")}
+  --outDir <dir>    Output directory (default: dist)
+  --ssr             Build for SSR
+  --minify false    Disable minification
+
+${logger.bold("Test Options:")}
+  --watch false     Run tests once (no watch mode)
+  --coverage        Generate coverage report
+  --grep <pattern>  Filter tests by pattern
+
+${logger.bold("Plugin Options:")}
+  --template <name>    Use a specific plugin template (default, minimal, withConfig)
+  --force              Overwrite existing directory
+  --skipInstall        Skip installing dependencies
+  --outDir <dir>       Output directory (default: dist)
+  --minify             Minify output
+  --sourcemap          Generate sourcemaps
+  --strict             Strict validation mode
+  --warningsAsErrors   Treat warnings as errors
+
+${logger.bold("Examples:")}
+  lyt create my-app
+  lyt create my-app --template minimal
+  lyt create my-app --template router
+  lyt create my-app --template full
+  lyt dev --port 3000
+  lyt build --ssr
+  lyt add component Button
+  lyt add page About
+  lyt add store user
+  lyt plugin create my-plugin
+  lyt plugin create my-plugin --template withConfig
+  lyt plugin build
+  lyt plugin validate
+`);
+}
+
+// src/index.ts
+if (__require.main === module) {
+  runCli().catch(console.error);
+}
+
+exports.add = add;
+exports.build = build;
+exports.buildPlugin = buildPlugin;
+exports.create = create;
+exports.createPlugin = createPlugin;
+exports.detectPackageManager = detectPackageManager;
+exports.dev = dev;
+exports.ensureDir = ensureDir;
+exports.exists = exists;
+exports.getAddCommand = getAddCommand;
+exports.getInstallCommand = getInstallCommand;
+exports.getRunCommand = getRunCommand;
+exports.listPluginTemplates = listPluginTemplates;
+exports.listTemplates = listTemplates;
+exports.logger = logger;
+exports.readFile = readFile;
+exports.runCli = runCli;
+exports.test = test;
+exports.validatePlugin = validatePlugin;
+exports.writeFile = writeFile;
+//# sourceMappingURL=lyt.cjs.map
+//# sourceMappingURL=lyt.cjs.map