gmoonc 0.0.2 → 0.0.4

package/README.md

@@ -1,18 +1,59 @@
-# Goalmoon Ctrl (gmoonc)
+# gmoonc
 
-Goalmoon Ctrl é um kit plugável para construir dashboards com autenticação e RBAC, compatível com Next e Vite.
+Goalmoon Ctrl (gmoonc): Complete dashboard installer for React projects.
 
-## Pacotes reais
-- **@gmoonc/core**
+## Installation
 
-## Instalação
 ```bash
-npm i @gmoonc/core
+npm install gmoonc
 ```
 
-## Links
-- Site: https://gmoonc.com
-- GitHub: https://github.com/gmoonc/gmoonc-packages
+## Usage
 
-## Nota
-O pacote "gmoonc" é um meta package e aponta para os módulos reais em @gmoonc/*.
+Run the installer in your React project root:
+
+```bash
+npx gmoonc
+```
+
+Or with options:
+
+```bash
+npx gmoonc --yes --base /app
+```
+
+## What it does
+
+1. **Copies dashboard templates** to `src/gmoonc/` in your project
+2. **Installs required dependencies** (react-router-dom, lucide-react, etc.)
+3. **Injects CSS** into your entrypoint (`src/main.tsx` or similar)
+4. **Patches your router** (BrowserRouter) to integrate gmoonc routes
+
+## Options
+
+- `--yes` / `-y`: Skip confirmations and install automatically
+- `--base <path>`: Base path for dashboard routes (default: `/app`)
+- `--skip-router-patch`: Skip automatic router integration
+- `--dry-run`: Show what would be done without making changes
+
+## After installation
+
+Your dashboard is now available at:
+- Home: `/app`
+- Admin: `/app/admin/*`
+- Auth: `/login`, `/register`, etc.
+
+The dashboard code is in `src/gmoonc/` and is independent. You can remove `gmoonc` from `package.json` if desired.
+
+## Uninstalling
+
+To remove gmoonc:
+
+1. Remove the CSS import from your entrypoint
+2. Revert changes to `App.tsx` (or restore from backup)
+3. Delete `src/gmoonc/` directory
+4. Remove `gmoonc` from `package.json`
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,618 @@
+"use strict";
+
+// src/cli/index.ts
+var import_commander = require("commander");
+var import_process = require("process");
+var import_path6 = require("path");
+
+// src/cli/lib/detect.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var ENTRYPOINT_CANDIDATES = [
+  "src/main.tsx",
+  "src/main.jsx",
+  "src/main.ts",
+  "src/main.js"
+];
+var ROUTER_CANDIDATES = [
+  "src/App.tsx",
+  "src/App.jsx",
+  "src/App.ts",
+  "src/App.js"
+];
+function detectPackageManager(cwd2) {
+  if ((0, import_fs.existsSync)((0, import_path.join)(cwd2, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if ((0, import_fs.existsSync)((0, import_path.join)(cwd2, "yarn.lock"))) {
+    return "yarn";
+  }
+  if ((0, import_fs.existsSync)((0, import_path.join)(cwd2, "package-lock.json"))) {
+    return "npm";
+  }
+  return "npm";
+}
+function findEntrypoint(cwd2) {
+  for (const candidate of ENTRYPOINT_CANDIDATES) {
+    const path = (0, import_path.join)(cwd2, candidate);
+    if ((0, import_fs.existsSync)(path)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function findRouterFile(cwd2) {
+  for (const candidate of ROUTER_CANDIDATES) {
+    const path = (0, import_path.join)(cwd2, candidate);
+    if ((0, import_fs.existsSync)(path)) {
+      const content = (0, import_fs.readFileSync)(path, "utf-8");
+      if (content.includes("<BrowserRouter") && content.includes("<Routes") && content.includes("<Route")) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function detectProject(cwd2) {
+  const packageJsonPath = (0, import_path.join)(cwd2, "package.json");
+  if (!(0, import_fs.existsSync)(packageJsonPath)) {
+    throw new Error(
+      "package.json not found. Make sure you run this command in the root of your React project."
+    );
+  }
+  const packageManager = detectPackageManager(cwd2);
+  const entrypoint = findEntrypoint(cwd2);
+  const routerFile = findRouterFile(cwd2);
+  return {
+    packageManager,
+    entrypoint,
+    routerFile,
+    packageJsonPath
+  };
+}
+
+// src/cli/lib/installDeps.ts
+var import_child_process = require("child_process");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+
+// src/cli/lib/logger.ts
+function logSuccess(message) {
+  console.log(`\u2713 ${message}`);
+}
+function logError(message) {
+  console.error(`\u274C ${message}`);
+}
+function logInfo(message) {
+  console.log(`\u2139\uFE0F  ${message}`);
+}
+function logWarning(message) {
+  console.warn(`\u26A0\uFE0F  ${message}`);
+}
+
+// src/cli/lib/installDeps.ts
+var REQUIRED_DEPS = [
+  "react-router-dom@^6.0.0",
+  "lucide-react@^0.303.0"
+];
+function collectDependenciesFromTemplates(templatesDir) {
+  return REQUIRED_DEPS;
+}
+function installDependencies(project, templatesDir, dryRun) {
+  const projectDir = (0, import_path2.join)(project.packageJsonPath, "..");
+  let existingDeps = {};
+  if ((0, import_fs2.existsSync)(project.packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse((0, import_fs2.readFileSync)(project.packageJsonPath, "utf-8"));
+      existingDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    } catch (error) {
+    }
+  }
+  const requiredDeps = collectDependenciesFromTemplates(templatesDir);
+  const packagesToInstall = [];
+  for (const dep of requiredDeps) {
+    const depName = dep.split("@")[0];
+    if (!existingDeps[depName]) {
+      packagesToInstall.push(dep);
+    }
+  }
+  if (packagesToInstall.length === 0) {
+    logSuccess("All required dependencies already installed");
+    return { success: true };
+  }
+  if (dryRun) {
+    logInfo(`[DRY RUN] Would install: ${packagesToInstall.join(", ")}`);
+    return { success: true };
+  }
+  const installCmd = project.packageManager === "pnpm" ? `pnpm add ${packagesToInstall.join(" ")}` : project.packageManager === "yarn" ? `yarn add ${packagesToInstall.join(" ")}` : `npm install ${packagesToInstall.join(" ")}`;
+  try {
+    logInfo(`Installing dependencies: ${packagesToInstall.join(", ")}`);
+    (0, import_child_process.execSync)(installCmd, {
+      stdio: "inherit",
+      cwd: projectDir
+    });
+    logSuccess("Dependencies installed");
+    return { success: true };
+  } catch (error) {
+    logError("Failed to install dependencies");
+    logError(`Try installing manually: ${installCmd}`);
+    return { success: false };
+  }
+}
+
+// src/cli/lib/templates.ts
+var import_path4 = require("path");
+var import_fs4 = require("fs");
+
+// src/cli/lib/fs.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+function ensureDirectoryExists(filePath) {
+  const dir = (0, import_path3.dirname)(filePath);
+  if (!(0, import_fs3.existsSync)(dir)) {
+    (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  }
+}
+function createBackupIfExists(filePath) {
+  if (!(0, import_fs3.existsSync)(filePath)) {
+    return null;
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "").slice(0, 15);
+  const ext = filePath.match(/\.[^.]+$/)?.[0] || "";
+  const base = filePath.replace(ext, "");
+  const backupPath = `${base}.gmoonc.bak-${timestamp}${ext}`;
+  const content = (0, import_fs3.readFileSync)(filePath, "utf-8");
+  (0, import_fs3.writeFileSync)(backupPath, content, "utf-8");
+  return backupPath;
+}
+function writeFileSafe(filePath, content) {
+  ensureDirectoryExists(filePath);
+  const backupPath = createBackupIfExists(filePath);
+  (0, import_fs3.writeFileSync)(filePath, content, "utf-8");
+  return backupPath;
+}
+function readFile(filePath) {
+  return (0, import_fs3.readFileSync)(filePath, "utf-8");
+}
+function copyDirectoryRecursive(src, dest) {
+  if (!(0, import_fs3.existsSync)(src)) {
+    return;
+  }
+  const stats = (0, import_fs3.statSync)(src);
+  if (!stats.isDirectory()) {
+    return;
+  }
+  ensureDirectoryExists(dest);
+  const entries = (0, import_fs3.readdirSync)(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = (0, import_path3.join)(src, entry.name);
+    const destPath = (0, import_path3.join)(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectoryRecursive(srcPath, destPath);
+    } else {
+      ensureDirectoryExists(destPath);
+      (0, import_fs3.copyFileSync)(srcPath, destPath);
+    }
+  }
+}
+
+// src/cli/lib/templates.ts
+function getTemplatesDir() {
+  const possiblePaths = [
+    (0, import_path4.join)(process.cwd(), "node_modules/gmoonc/src/templates"),
+    (0, import_path4.join)(process.cwd(), "packages/gmoonc/src/templates"),
+    (0, import_path4.join)(__dirname, "../../../src/templates"),
+    // From dist/cli/lib
+    (0, import_path4.join)(__dirname, "../../templates")
+    // From src/cli/lib (dev)
+  ];
+  for (const path of possiblePaths) {
+    if ((0, import_fs4.existsSync)(path)) {
+      return path;
+    }
+  }
+  return (0, import_path4.join)(__dirname, "../../templates");
+}
+function copySharedTemplates(consumerDir, templatesDir, dryRun) {
+  const sharedTemplatesDir = (0, import_path4.join)(templatesDir, "shared/src/gmoonc");
+  const destDir = (0, import_path4.join)(consumerDir, "src/gmoonc");
+  if (dryRun) {
+    logInfo(`[DRY RUN] Would copy templates from ${sharedTemplatesDir} to ${destDir}`);
+    return { success: true };
+  }
+  logInfo("Copying dashboard templates...");
+  copyDirectoryRecursive(sharedTemplatesDir, destDir);
+  logSuccess("Templates copied to src/gmoonc/");
+  return { success: true };
+}
+function copyViteRouterTemplates(consumerDir, templatesDir, dryRun) {
+  const viteTemplatesDir = (0, import_path4.join)(templatesDir, "vite/src/gmoonc/router");
+  const destDir = (0, import_path4.join)(consumerDir, "src/gmoonc/router");
+  if (dryRun) {
+    logInfo(`[DRY RUN] Would copy router templates from ${viteTemplatesDir} to ${destDir}`);
+    return { success: true };
+  }
+  logInfo("Copying router templates...");
+  copyDirectoryRecursive(viteTemplatesDir, destDir);
+  logSuccess("Router templates copied");
+  return { success: true };
+}
+
+// src/cli/lib/patchEntryCss.ts
+function patchEntryCss(entrypointPath, dryRun) {
+  if (dryRun) {
+    return { success: true, backupPath: null };
+  }
+  const content = readFile(entrypointPath);
+  const hasThemeCss = content.includes("./gmoonc/styles/theme.css") || content.includes("gmoonc/styles/theme.css");
+  const hasGmooncCss = content.includes("./gmoonc/styles/gmoonc.css") || content.includes("gmoonc/styles/gmoonc.css");
+  if (hasThemeCss && hasGmooncCss) {
+    logSuccess("CSS imports already exist");
+    return { success: true, backupPath: null };
+  }
+  const importRegex = /^import\s+.*$/gm;
+  const imports = content.match(importRegex) || [];
+  let newContent = content;
+  const cssImports = [];
+  if (!hasThemeCss) {
+    cssImports.push('import "./gmoonc/styles/theme.css";');
+  }
+  if (!hasGmooncCss) {
+    cssImports.push('import "./gmoonc/styles/gmoonc.css";');
+  }
+  if (imports.length > 0) {
+    const lastImport = imports[imports.length - 1];
+    const lastImportIndex = content.lastIndexOf(lastImport);
+    const insertIndex = lastImportIndex + lastImport.length;
+    newContent = content.slice(0, insertIndex) + "\n" + cssImports.join("\n") + content.slice(insertIndex);
+  } else {
+    newContent = cssImports.join("\n") + "\n" + content;
+  }
+  const backupPath = writeFileSafe(entrypointPath, newContent);
+  if (backupPath) {
+    logSuccess(`CSS import added (backup: ${backupPath})`);
+  } else {
+    logSuccess("CSS import added");
+  }
+  return { success: true, backupPath };
+}
+
+// src/cli/lib/patchBrowserRouter.ts
+var import_fs8 = require("fs");
+var import_path5 = require("path");
+function extractRouteComponents(appContent) {
+  const indexRouteMatch = appContent.match(/<Route\s+path=["']\/["']\s+element=\{<(\w+)\s*\/?>\}\s*\/?>/);
+  const indexComponent = indexRouteMatch ? indexRouteMatch[1] : null;
+  const notFoundRouteMatch = appContent.match(/<Route\s+path=["']\*["']\s+element=\{<(\w+)\s*\/?>\}\s*\/?>/);
+  const notFoundComponent = notFoundRouteMatch ? notFoundRouteMatch[1] : null;
+  let indexImport = null;
+  let notFoundImport = null;
+  const lines = appContent.split("\n");
+  if (indexComponent) {
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("import")) {
+        const defaultImportMatch = trimmed.match(/import\s+(\w+)\s+from\s+["']([^"']+)["']/);
+        if (defaultImportMatch && defaultImportMatch[1] === indexComponent) {
+          indexImport = trimmed;
+          break;
+        }
+        const namedImportMatch = trimmed.match(/import\s+\{[^}]*\b(\w+)\b[^}]*\}\s+from\s+["']([^"']+)["']/);
+        if (namedImportMatch && namedImportMatch[1] === indexComponent) {
+          indexImport = trimmed;
+          break;
+        }
+      }
+    }
+  }
+  if (notFoundComponent) {
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("import")) {
+        const defaultImportMatch = trimmed.match(/import\s+(\w+)\s+from\s+["']([^"']+)["']/);
+        if (defaultImportMatch && defaultImportMatch[1] === notFoundComponent) {
+          notFoundImport = trimmed;
+          break;
+        }
+        const namedImportMatch = trimmed.match(/import\s+\{[^}]*\b(\w+)\b[^}]*\}\s+from\s+["']([^"']+)["']/);
+        if (namedImportMatch && namedImportMatch[1] === notFoundComponent) {
+          notFoundImport = trimmed;
+          break;
+        }
+      }
+    }
+  }
+  return { indexImport, notFoundImport, indexComponent, notFoundComponent };
+}
+function convertImportToRelative(importLine, appRoutesPath, appPath) {
+  const pathMatch = importLine.match(/from\s+["']([^"']+)["']/);
+  if (!pathMatch) {
+    return importLine;
+  }
+  const originalPath = pathMatch[1];
+  if (originalPath.startsWith("./") || originalPath.startsWith("../")) {
+    const appDir = appPath.substring(0, appPath.lastIndexOf("/"));
+    const appRoutesDir = appRoutesPath.substring(0, appRoutesPath.lastIndexOf("/"));
+    const resolvedPath = (0, import_path5.join)(appDir, originalPath);
+    const relativePath = (0, import_path5.relative)(appRoutesDir, resolvedPath);
+    const normalizedPath = relativePath.replace(/\\/g, "/");
+    const finalPath = normalizedPath.startsWith(".") ? normalizedPath : "./" + normalizedPath;
+    return importLine.replace(pathMatch[1], finalPath);
+  }
+  return importLine;
+}
+function generateAppRoutes(consumerDir, basePath, indexImport, notFoundImport, indexComponent, notFoundComponent, appPath, dryRun) {
+  const appRoutesPath = (0, import_path5.join)(consumerDir, "src/gmoonc/router/AppRoutes.tsx");
+  if (dryRun) {
+    logInfo(`[DRY RUN] Would generate ${appRoutesPath}`);
+    return { success: true };
+  }
+  ensureDirectoryExists(appRoutesPath);
+  const routes = [];
+  if (indexComponent) {
+    routes.push(`    { path: "/", element: <${indexComponent} /> }`);
+  }
+  routes.push(`    ...createGmooncRoutes({ basePath: "${basePath}" })`);
+  if (notFoundComponent) {
+    routes.push(`    { path: "*", element: <${notFoundComponent} /> }`);
+  }
+  const imports = [
+    "import { useRoutes, type RouteObject } from 'react-router-dom';",
+    "import { createGmooncRoutes } from './createGmooncRoutes';"
+  ];
+  if (indexImport) {
+    const convertedImport = convertImportToRelative(indexImport, appRoutesPath, appPath);
+    imports.push(convertedImport);
+  }
+  if (notFoundImport) {
+    const convertedImport = convertImportToRelative(notFoundImport, appRoutesPath, appPath);
+    imports.push(convertedImport);
+  }
+  const content = `${imports.join("\n")}
+
+export function GMooncAppRoutes({ basePath = "${basePath}" }: { basePath?: string }) {
+  const allRoutes: RouteObject[] = [
+${routes.join(",\n")}
+  ];
+
+  return useRoutes(allRoutes);
+}
+`;
+  writeFileSafe(appRoutesPath, content);
+  logSuccess("Generated src/gmoonc/router/AppRoutes.tsx");
+  return { success: true };
+}
+function patchBrowserRouter(consumerDir, basePath, dryRun) {
+  const appCandidates = ["src/App.tsx", "src/App.jsx", "src/App.ts", "src/App.js"];
+  let appPath = null;
+  for (const candidate of appCandidates) {
+    const fullPath = (0, import_path5.join)(consumerDir, candidate);
+    if ((0, import_fs8.existsSync)(fullPath)) {
+      appPath = fullPath;
+      break;
+    }
+  }
+  if (!appPath) {
+    return {
+      success: false,
+      backupPath: null,
+      message: "Could not find App.tsx, App.jsx, App.ts, or App.js"
+    };
+  }
+  const appContent = readFile(appPath);
+  if (appContent.includes("GMooncAppRoutes") || appContent.includes("gmooncAppRoutes")) {
+    return {
+      success: false,
+      backupPath: null,
+      message: "App.tsx already uses GMooncAppRoutes"
+    };
+  }
+  if (!appContent.includes("<BrowserRouter") || !appContent.includes("<Routes") || !appContent.includes("<Route")) {
+    return {
+      success: false,
+      backupPath: null,
+      message: "BrowserRouter pattern not found in App.tsx"
+    };
+  }
+  const { indexImport, notFoundImport, indexComponent, notFoundComponent } = extractRouteComponents(appContent);
+  if (!indexComponent && !notFoundComponent) {
+    return {
+      success: false,
+      backupPath: null,
+      message: 'Could not find Index or NotFound components in App.tsx. Please ensure you have <Route path="/" ...> and/or <Route path="*" ...>'
+    };
+  }
+  if (dryRun) {
+    logInfo(`[DRY RUN] Would patch ${appPath}`);
+    return { success: true, backupPath: null };
+  }
+  generateAppRoutes(consumerDir, basePath, indexImport, notFoundImport, indexComponent, notFoundComponent, appPath, false);
+  const backupPath = writeFileSafe(appPath, "");
+  const lines = appContent.split("\n");
+  let hasBrowserRouterImport = false;
+  let reactRouterImportIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.includes("from") && line.includes("react-router-dom")) {
+      reactRouterImportIndex = i;
+      if (line.includes("BrowserRouter")) {
+        hasBrowserRouterImport = true;
+      }
+    }
+  }
+  if (!hasBrowserRouterImport) {
+    if (reactRouterImportIndex >= 0) {
+      const existingLine = lines[reactRouterImportIndex];
+      if (existingLine.includes("{") && existingLine.includes("}")) {
+        const updatedLine = existingLine.replace(/\{([^}]+)\}/, (match, imports) => {
+          const importList = imports.split(",").map((s) => s.trim());
+          if (!importList.includes("BrowserRouter")) {
+            importList.push("BrowserRouter");
+          }
+          return `{ ${importList.join(", ")} }`;
+        });
+        lines[reactRouterImportIndex] = updatedLine;
+      } else {
+        lines.splice(reactRouterImportIndex + 1, 0, `import { BrowserRouter } from "react-router-dom";`);
+      }
+    } else {
+      const importLine2 = `import { BrowserRouter } from "react-router-dom";`;
+      let lastImportIndex2 = -1;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith("import ") || line.startsWith("import{") || line.startsWith("import	")) {
+          lastImportIndex2 = i;
+        } else if (line && lastImportIndex2 >= 0 && !line.startsWith("//") && !line.startsWith("/*")) {
+          break;
+        }
+      }
+      if (lastImportIndex2 >= 0) {
+        lines.splice(lastImportIndex2 + 1, 0, importLine2);
+      } else {
+        lines.unshift(importLine2);
+      }
+    }
+  }
+  const importLine = `import { GMooncAppRoutes } from "./gmoonc/router/AppRoutes";`;
+  let lastImportIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith("import ") || line.startsWith("import{") || line.startsWith("import	")) {
+      lastImportIndex = i;
+    } else if (line && lastImportIndex >= 0 && !line.startsWith("//") && !line.startsWith("/*")) {
+      break;
+    }
+  }
+  if (lastImportIndex >= 0) {
+    lines.splice(lastImportIndex + 1, 0, importLine);
+  } else {
+    lines.unshift(importLine);
+  }
+  let newContent = lines.join("\n");
+  const routesStartMatch = newContent.match(/<Routes\s*[^>]*>/);
+  if (!routesStartMatch) {
+    return {
+      success: false,
+      backupPath,
+      message: "Could not find <Routes> tag"
+    };
+  }
+  const routesStartIndex = routesStartMatch.index;
+  let depth = 1;
+  let routesEndIndex = routesStartIndex + routesStartMatch[0].length;
+  for (let i = routesEndIndex; i < newContent.length; i++) {
+    if (newContent.substring(i).startsWith("<Routes")) {
+      depth++;
+    } else if (newContent.substring(i).startsWith("</Routes>")) {
+      depth--;
+      if (depth === 0) {
+        routesEndIndex = i + "</Routes>".length;
+        break;
+      }
+    }
+  }
+  if (depth !== 0) {
+    return {
+      success: false,
+      backupPath,
+      message: "Could not find matching </Routes> tag"
+    };
+  }
+  const routesLine = lines.find((line, idx) => {
+    const lineContent = line.trim();
+    return lineContent.startsWith("<Routes") && idx <= routesStartIndex;
+  });
+  const indent = routesLine ? routesLine.match(/^(\s*)/)?.[1] || "  " : "  ";
+  const before = newContent.substring(0, routesStartIndex);
+  const after = newContent.substring(routesEndIndex);
+  const replacement = `${indent}<GMooncAppRoutes basePath="${basePath}" />`;
+  newContent = before + replacement + after;
+  if (!newContent.match(/<Routes[^>]*>/g) && !newContent.match(/<Route[^>]*>/g)) {
+    newContent = newContent.replace(/import\s+{[^}]*Routes[^}]*}\s+from\s+["']react-router-dom["'];?\n?/g, "");
+    newContent = newContent.replace(/import\s+{[^}]*Route[^}]*}\s+from\s+["']react-router-dom["'];?\n?/g, "");
+  }
+  writeFileSafe(appPath, newContent);
+  logSuccess(`Patched ${appPath} (backup: ${backupPath})`);
+  return { success: true, backupPath };
+}
+
+// src/cli/index.ts
+var program = new import_commander.Command();
+program.name("gmoonc").description("Goalmoon Ctrl (gmoonc): Install complete dashboard into your React project").version("0.0.3").option("-y, --yes", "Skip confirmations and install automatically").option("--base <path>", "Base path for dashboard routes", "/app").option("--skip-router-patch", "Skip automatic router integration (only copy files and inject CSS)").option("--dry-run", "Show what would be done without making changes").action(async (options) => {
+  try {
+    const projectDir = (0, import_process.cwd)();
+    const basePath = options.base || "/app";
+    const dryRun = options.dryRun || false;
+    const skipRouterPatch = options.skipRouterPatch || false;
+    const safeBasePath = basePath === "/" ? "/app" : basePath;
+    logInfo("\u{1F50D} Detecting React project...");
+    const project = detectProject(projectDir);
+    logSuccess(`Package manager: ${project.packageManager}`);
+    logSuccess("package.json found");
+    if (!project.entrypoint) {
+      logError("Entrypoint not found.");
+      logError("Looking for: src/main.tsx, src/main.jsx, src/main.ts, src/main.js");
+      process.exit(1);
+    }
+    logSuccess(`Entrypoint found: ${project.entrypoint}`);
+    if (!skipRouterPatch && !project.routerFile) {
+      logWarning("Router file not found or BrowserRouter pattern not detected.");
+      logWarning("Router patch will be skipped. You can integrate manually later.");
+    } else if (!skipRouterPatch) {
+      logSuccess(`Router file found: ${project.routerFile}`);
+    }
+    const templatesDir = getTemplatesDir();
+    logInfo(`Templates directory: ${templatesDir}`);
+    logInfo("\n\u{1F4E6} Installing dependencies...");
+    const depsResult = installDependencies(project, templatesDir, dryRun);
+    if (!depsResult.success && !dryRun) {
+      process.exit(1);
+    }
+    logInfo("\n\u{1F4CB} Copying dashboard templates...");
+    const sharedResult = copySharedTemplates(projectDir, templatesDir, dryRun);
+    if (!sharedResult.success) {
+      logError("Failed to copy shared templates");
+      process.exit(1);
+    }
+    const routerResult = copyViteRouterTemplates(projectDir, templatesDir, dryRun);
+    if (!routerResult.success) {
+      logError("Failed to copy router templates");
+      process.exit(1);
+    }
+    logInfo("\n\u{1F4DD} Injecting CSS imports...");
+    const entrypointPath = (0, import_path6.join)(projectDir, project.entrypoint);
+    const cssResult = patchEntryCss(entrypointPath, dryRun);
+    if (!cssResult.success && !dryRun) {
+      logError("Failed to inject CSS");
+      process.exit(1);
+    }
+    if (!skipRouterPatch && project.routerFile) {
+      logInfo("\n\u{1F527} Patching router...");
+      const routerPatchResult = patchBrowserRouter(projectDir, safeBasePath, dryRun);
+      if (!routerPatchResult.success && !dryRun) {
+        logWarning(`Router patch failed: ${routerPatchResult.message}`);
+        logWarning("You can integrate manually by importing GMooncAppRoutes in your App.tsx");
+      } else if (routerPatchResult.success) {
+        logSuccess("Router patched successfully");
+      }
+    } else if (skipRouterPatch) {
+      logInfo("\n\u23ED\uFE0F  Skipping router patch (--skip-router-patch)");
+    } else {
+      logInfo("\n\u23ED\uFE0F  Skipping router patch (router not detected)");
+    }
+    logSuccess("\n\u2705 Installation complete!");
+    logInfo("\nYour dashboard is now available at:");
+    logInfo(`  - Home: ${safeBasePath}`);
+    logInfo(`  - Admin: ${safeBasePath}/admin/*`);
+    logInfo(`  - Auth: /login, /register, etc.`);
+    logInfo("\nYou can now remove gmoonc from package.json if desired.");
+    logInfo("The dashboard code is in src/gmoonc/ and is independent.");
+  } catch (error) {
+    logError(`Error: ${error.message}`);
+    if (error.stack && process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+});
+program.parse();