@prmvx/frontend-forge 0.1.0

package/dist/cli.js

@@ -0,0 +1,662 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import fs7 from "fs";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { intro, isCancel, cancel, spinner } from "@clack/prompts";
+
+// src/utils/detectProject.ts
+import fs from "fs";
+function validateProject() {
+  if (!fs.existsSync("package.json")) {
+    throw new Error(
+      "Could not find package.json.\nPlease run this command inside an existing Next.js project."
+    );
+  }
+  const pkg = JSON.parse(
+    fs.readFileSync("package.json", "utf-8")
+  );
+  if (!pkg.dependencies?.next) {
+    throw new Error(
+      "Next.js project not detected.\nCurrent version only supports Next.js."
+    );
+  }
+}
+
+// src/utils/detectProjectStructure.ts
+import fs2 from "fs";
+import path from "path";
+function detectProjectStructure() {
+  const cwd = process.cwd();
+  if (fs2.existsSync(path.join(cwd, "app"))) {
+    return {
+      useSrc: false,
+      root: "",
+      appDir: "app"
+    };
+  }
+  if (fs2.existsSync(path.join(cwd, "src", "app"))) {
+    return {
+      useSrc: true,
+      root: "src",
+      appDir: "src/app"
+    };
+  }
+  if (fs2.existsSync(path.join(cwd, "src"))) {
+    return {
+      useSrc: true,
+      root: "src",
+      appDir: "src/app"
+    };
+  }
+  return {
+    useSrc: false,
+    root: "",
+    appDir: "app"
+  };
+}
+
+// src/utils/copyArchitecture.ts
+import path4 from "path";
+
+// src/utils/copyTemplate.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/resolveTemplatePath.ts
+import path2 from "path";
+function normalizePath(relativePath) {
+  return relativePath.split(path2.sep).join("/");
+}
+function remapCoreModulePath(normalizedPath, architecture) {
+  if (architecture === "feature") {
+    if (normalizedPath.startsWith("src/components/")) {
+      return normalizedPath.replace(
+        "src/components/",
+        "src/shared/components/"
+      );
+    }
+    if (normalizedPath.startsWith("src/hooks/")) {
+      return normalizedPath.replace("src/hooks/", "src/shared/hooks/");
+    }
+    if (normalizedPath.startsWith("src/utils/")) {
+      return normalizedPath.replace("src/utils/", "src/shared/utils/");
+    }
+    if (normalizedPath.startsWith("src/providers/")) {
+      return normalizedPath.replace("src/providers/", "src/shared/providers/");
+    }
+    if (normalizedPath.startsWith("src/services/")) {
+      return normalizedPath.replace("src/services/", "src/features/home/services/");
+    }
+    if (normalizedPath.startsWith("src/constants/")) {
+      return normalizedPath.replace("src/constants/", "src/features/home/constants/");
+    }
+  }
+  return normalizedPath;
+}
+function resolveTemplatePath(relativePath, options) {
+  let normalized = normalizePath(relativePath);
+  if (normalized === "src/app" || normalized.startsWith("src/app/")) {
+    return null;
+  }
+  if (options.remapCore && options.architecture) {
+    normalized = remapCoreModulePath(normalized, options.architecture);
+  }
+  if (!options.structure.useSrc && normalized.startsWith("src/")) {
+    normalized = normalized.slice(4);
+  }
+  return normalized.split("/").join(path2.sep);
+}
+function shouldSkipTemplatePath(relativePath) {
+  const normalized = normalizePath(relativePath);
+  return normalized === "src/app" || normalized.startsWith("src/app/");
+}
+
+// src/utils/copyTemplate.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+async function getAllFiles(dir) {
+  const entries = await fs3.readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await getAllFiles(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function copyTemplateDir(relativePath, options) {
+  const templatePath = path3.resolve(__dirname, "../templates", relativePath);
+  const targetPath = process.cwd();
+  const files = await getAllFiles(templatePath);
+  const createdDirs = /* @__PURE__ */ new Set();
+  let created = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const file of files) {
+    if (options.exclude?.(file)) {
+      continue;
+    }
+    const relativeFile = path3.relative(templatePath, file);
+    if (shouldSkipTemplatePath(relativeFile)) {
+      continue;
+    }
+    const destRelative = resolveTemplatePath(relativeFile, {
+      structure: options.structure,
+      architecture: options.architecture,
+      remapCore: options.remapCore
+    });
+    if (!destRelative) {
+      continue;
+    }
+    const dest = path3.join(targetPath, destRelative);
+    const destDir = path3.dirname(dest);
+    try {
+      if (await fs3.pathExists(dest)) {
+        skipped++;
+        continue;
+      }
+      if (!createdDirs.has(destDir)) {
+        await fs3.ensureDir(destDir);
+        createdDirs.add(destDir);
+      }
+      await fs3.copy(file, dest);
+      created++;
+    } catch {
+      failed++;
+    }
+  }
+  return { created, skipped, failed };
+}
+
+// src/utils/copyArchitecture.ts
+async function copyArchitecture(framework, architecture, structure) {
+  return copyTemplateDir(
+    path4.join("architectures", framework, architecture),
+    { structure, architecture }
+  );
+}
+
+// src/utils/copyModules.ts
+import path5 from "path";
+async function copyModules(modules2, structure, architecture) {
+  const stats = { created: 0, skipped: 0, failed: 0 };
+  for (const module of modules2) {
+    const result = await copyTemplateDir(path5.join("modules", module), {
+      structure,
+      architecture,
+      remapCore: module === "core",
+      exclude: (filePath) => filePath.endsWith("module.ts")
+    });
+    stats.created += result.created;
+    stats.skipped += result.skipped;
+    stats.failed += result.failed;
+  }
+  return stats;
+}
+
+// src/utils/extendProjectFiles.ts
+import fs4 from "fs-extra";
+import path6 from "path";
+function getAppFilePath(structure, fileName) {
+  return path6.join(process.cwd(), structure.appDir, fileName);
+}
+function getProvidersImport(architecture) {
+  if (architecture === "feature") {
+    return "@/shared/providers";
+  }
+  return "@/providers";
+}
+function getPageImport(architecture) {
+  if (architecture === "feature") {
+    return "@/features/home/components/HomePage";
+  }
+  return "@/components/home/HomeView";
+}
+function getPageComponent(architecture) {
+  if (architecture === "feature") {
+    return "HomePage";
+  }
+  return "HomeView";
+}
+async function extendProjectFiles(architecture, structure) {
+  await extendLayout(structure, architecture);
+  await extendPage(structure, architecture);
+}
+async function extendLayout(structure, architecture) {
+  const layoutPath = getAppFilePath(structure, "layout.tsx");
+  if (!await fs4.pathExists(layoutPath)) {
+    return;
+  }
+  const content = await fs4.readFile(layoutPath, "utf-8");
+  const providersImport = getProvidersImport(architecture);
+  if (content.includes("<Providers>")) {
+    return;
+  }
+  let updated = content;
+  if (!content.includes(providersImport) && !content.includes('from "@/providers"') && !content.includes("from '@/providers'")) {
+    const importLine = `import { Providers } from "${providersImport}";
+`;
+    const lastImportIndex = updated.lastIndexOf("import ");
+    if (lastImportIndex !== -1) {
+      const insertAt = updated.indexOf("\n", lastImportIndex) + 1;
+      updated = updated.slice(0, insertAt) + importLine + updated.slice(insertAt);
+    } else {
+      updated = importLine + updated;
+    }
+  }
+  updated = updated.replace(/(<body[^>]*>)/, "$1\n        <Providers>");
+  updated = updated.replace("</body>", "        </Providers>\n      </body>");
+  if (updated !== content) {
+    await fs4.writeFile(layoutPath, updated);
+  }
+}
+async function extendPage(structure, architecture) {
+  const pagePath = getAppFilePath(structure, "page.tsx");
+  if (!await fs4.pathExists(pagePath)) {
+    return;
+  }
+  const content = await fs4.readFile(pagePath, "utf-8");
+  const pageImport = getPageImport(architecture);
+  const pageComponent = getPageComponent(architecture);
+  if (content.includes(pageComponent)) {
+    return;
+  }
+  const isDefaultTemplate = content.includes("Get started by editing") || content.includes("next.svg") || content.includes("vercel.svg");
+  if (!isDefaultTemplate) {
+    return;
+  }
+  const updated = `import { ${pageComponent} } from "${pageImport}";
+
+export default function Home() {
+  return <${pageComponent} />;
+}
+`;
+  await fs4.writeFile(pagePath, updated);
+}
+
+// src/utils/readModule.ts
+import fs5 from "fs-extra";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path7.dirname(__filename2);
+async function readModule(moduleName) {
+  const modulePath = path7.resolve(
+    __dirname2,
+    "../templates/modules",
+    moduleName,
+    "module.ts"
+  );
+  const content = await fs5.readFile(modulePath, "utf-8");
+  const dataUrl = `data:text/javascript;charset=utf-8,${encodeURIComponent(content)}`;
+  const { default: moduleDef } = await import(dataUrl);
+  return moduleDef;
+}
+
+// src/utils/installDependencies.ts
+import { execa } from "execa";
+var installCommands = {
+  npm: { command: "npm", dependencies: ["install"], devDependencies: ["install", "-D"] },
+  pnpm: { command: "pnpm", dependencies: ["add"], devDependencies: ["add", "-D"] },
+  yarn: { command: "yarn", dependencies: ["add"], devDependencies: ["add", "-D"] },
+  bun: { command: "bun", dependencies: ["add"], devDependencies: ["add", "-d"] }
+};
+async function installDependencies(modules2, packageManager) {
+  const dependencies = [
+    ...new Set(modules2.flatMap((module) => module.dependencies))
+  ];
+  const devDependencies = [
+    ...new Set(modules2.flatMap((module) => module.devDependencies))
+  ];
+  const totalCount = dependencies.length + devDependencies.length;
+  if (totalCount === 0) {
+    return 0;
+  }
+  const { command, dependencies: depsArgs, devDependencies: devArgs } = installCommands[packageManager];
+  try {
+    if (dependencies.length > 0) {
+      await execa(command, [...depsArgs, ...dependencies], {
+        stdio: "inherit",
+        cwd: process.cwd()
+      });
+    }
+    if (devDependencies.length > 0) {
+      await execa(command, [...devArgs, ...devDependencies], {
+        stdio: "inherit",
+        cwd: process.cwd()
+      });
+    }
+    return totalCount;
+  } catch {
+    throw new Error(
+      "Failed to install dependencies.\nPlease resolve the issue and run the command again."
+    );
+  }
+}
+
+// src/utils/detectPackageManager.ts
+import fs6 from "fs";
+import path8 from "path";
+import { execa as execa2 } from "execa";
+function detectPackageManager() {
+  const root = process.cwd();
+  if (fs6.existsSync(path8.join(root, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (fs6.existsSync(path8.join(root, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (fs6.existsSync(path8.join(root, "bun.lockb")) || fs6.existsSync(path8.join(root, "bun.lock"))) {
+    return "bun";
+  }
+  if (fs6.existsSync(path8.join(root, "package-lock.json"))) {
+    return "npm";
+  }
+  return null;
+}
+async function validatePackageManager(packageManager) {
+  const result = await execa2(packageManager, ["--version"], {
+    reject: false
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `${packageManager} is not available.
+Please install ${packageManager} and try again.`
+    );
+  }
+}
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var logger = {
+  success(message) {
+    console.log(`${pc.green("\u2713")} ${message}`);
+  },
+  info(message) {
+    console.log(`${pc.cyan("\u2139")} ${message}`);
+  },
+  warning(message) {
+    console.log(`${pc.yellow("\u26A0")} ${message}`);
+  },
+  error(message) {
+    for (const line of message.split("\n")) {
+      console.log(`${pc.red("\u2716")} ${line}`);
+    }
+  }
+};
+
+// src/prompts/architecture.ts
+import { select } from "@clack/prompts";
+
+// src/config/architectures.ts
+var architectures = [
+  {
+    value: "standard",
+    label: "Standard",
+    hint: "Simple folder structure"
+  },
+  {
+    value: "enterprise",
+    label: "Enterprise",
+    hint: "Scalable enterprise architecture"
+  },
+  {
+    value: "feature",
+    label: "Feature Based",
+    hint: "Organize code by feature"
+  }
+];
+
+// src/prompts/architecture.ts
+async function selectArchitecture() {
+  return await select({
+    message: "Choose project architecture",
+    options: architectures.map((item) => ({
+      value: item.value,
+      label: item.label,
+      hint: item.hint
+    }))
+  });
+}
+
+// src/prompts/modules.ts
+import { multiselect } from "@clack/prompts";
+
+// src/config/modules.ts
+var modules = [
+  {
+    value: "core",
+    label: "Core",
+    hint: "Basic starter files"
+  },
+  {
+    value: "axios",
+    label: "Axios",
+    hint: "API Client"
+  },
+  {
+    value: "zustand",
+    label: "Zustand",
+    hint: "State Management"
+  }
+];
+
+// src/prompts/modules.ts
+async function selectModules() {
+  return await multiselect({
+    message: "Select modules",
+    options: modules.map((item) => ({
+      value: item.value,
+      label: item.label,
+      hint: item.hint
+    })),
+    required: true
+  });
+}
+
+// src/prompts/packageManager.ts
+import { select as select2 } from "@clack/prompts";
+async function selectPackageManager() {
+  return await select2({
+    message: "Choose package manager",
+    options: [
+      { value: "npm", label: "npm" },
+      { value: "pnpm", label: "pnpm" },
+      { value: "yarn", label: "yarn" },
+      { value: "bun", label: "bun" }
+    ],
+    initialValue: "npm"
+  });
+}
+
+// src/commands/init.ts
+function getVersion() {
+  const dir = path9.dirname(fileURLToPath3(import.meta.url));
+  const pkg = JSON.parse(
+    fs7.readFileSync(path9.join(dir, "../package.json"), "utf-8")
+  );
+  return pkg.version;
+}
+function getArchitectureLabel(value) {
+  return architectures.find((item) => item.value === value)?.label ?? value;
+}
+function getModuleLabel(value) {
+  return modules.find((item) => item.value === value)?.label ?? value;
+}
+function printSummary(options) {
+  console.log("");
+  logger.success("Project initialized successfully.");
+  console.log("");
+  console.log("Framework:");
+  console.log("Next.js");
+  console.log("");
+  console.log("Architecture:");
+  console.log(getArchitectureLabel(options.architecture));
+  console.log("");
+  console.log("Modules:");
+  for (const module of options.selectedModules) {
+    console.log(getModuleLabel(module));
+  }
+  console.log("");
+  console.log("Package Manager:");
+  console.log(options.packageManager);
+  console.log("");
+  console.log("Dependencies Installed:");
+  console.log(options.dependenciesInstalled);
+  console.log("");
+  console.log("Files Created:");
+  console.log(options.filesCreated);
+  console.log("");
+  console.log("Files Skipped:");
+  console.log(options.filesSkipped);
+  console.log("");
+  console.log("Done.");
+  console.log("");
+  logger.success("Happy Coding!");
+}
+async function initCommand() {
+  intro("Frontend Init");
+  logger.info("Production Ready Frontend Starter");
+  logger.info(`Version ${getVersion()}`);
+  const detectSpinner = spinner();
+  detectSpinner.start("Detecting project...");
+  try {
+    validateProject();
+    detectSpinner.stop("Success");
+  } catch (error) {
+    detectSpinner.stop("Failed");
+    logger.error(
+      error instanceof Error ? error.message : "Project validation failed."
+    );
+    return;
+  }
+  const architectureSpinner = spinner();
+  architectureSpinner.start("Selecting architecture...");
+  const architecture = await selectArchitecture();
+  if (isCancel(architecture) || !architecture) {
+    architectureSpinner.stop("Failed");
+    cancel("Operation cancelled.");
+    return;
+  }
+  architectureSpinner.stop("Success");
+  const modulesSpinner = spinner();
+  modulesSpinner.start("Selecting modules...");
+  const selectedModules = await selectModules();
+  if (isCancel(selectedModules) || selectedModules.length === 0) {
+    modulesSpinner.stop("Failed");
+    cancel("Operation cancelled.");
+    return;
+  }
+  modulesSpinner.stop("Success");
+  const structure = detectProjectStructure();
+  const moduleDefinitions = await Promise.all(
+    selectedModules.map((module) => readModule(module))
+  );
+  const detected = detectPackageManager();
+  let packageManager;
+  if (detected) {
+    packageManager = detected;
+    logger.info(`Detected: ${packageManager}`);
+  } else {
+    const selected = await selectPackageManager();
+    if (isCancel(selected) || !selected) {
+      cancel("Operation cancelled.");
+      return;
+    }
+    packageManager = selected;
+    logger.info(`Using ${packageManager}`);
+  }
+  try {
+    await validatePackageManager(packageManager);
+  } catch (error) {
+    logger.error(
+      error instanceof Error ? error.message : "Package manager not available."
+    );
+    return;
+  }
+  let dependenciesInstalled = 0;
+  const installSpinner = spinner();
+  installSpinner.start("Installing dependencies...");
+  try {
+    dependenciesInstalled = await installDependencies(
+      moduleDefinitions,
+      packageManager
+    );
+    installSpinner.stop("Success");
+  } catch (error) {
+    installSpinner.stop("Failed");
+    logger.error(
+      error instanceof Error ? error.message : "Failed to install dependencies.\nPlease resolve the issue and run the command again."
+    );
+    return;
+  }
+  const architectureCopySpinner = spinner();
+  architectureCopySpinner.start("Copying architecture...");
+  let architectureStats;
+  try {
+    architectureStats = await copyArchitecture(
+      "next",
+      architecture,
+      structure
+    );
+    architectureCopySpinner.stop("Success");
+  } catch (error) {
+    architectureCopySpinner.stop("Failed");
+    logger.error(
+      error instanceof Error ? error.message : "Failed to copy architecture."
+    );
+    return;
+  }
+  const modulesCopySpinner = spinner();
+  modulesCopySpinner.start("Copying modules...");
+  let moduleStats;
+  try {
+    moduleStats = await copyModules(
+      selectedModules,
+      structure,
+      architecture
+    );
+    modulesCopySpinner.stop("Success");
+  } catch (error) {
+    modulesCopySpinner.stop("Failed");
+    logger.error(
+      error instanceof Error ? error.message : "Failed to copy modules."
+    );
+    return;
+  }
+  try {
+    await extendProjectFiles(architecture, structure);
+  } catch (error) {
+    logger.error(
+      error instanceof Error ? error.message : "Failed to extend project files."
+    );
+    return;
+  }
+  const finishingSpinner = spinner();
+  finishingSpinner.start("Finishing...");
+  printSummary({
+    architecture,
+    selectedModules,
+    packageManager,
+    dependenciesInstalled,
+    filesCreated: architectureStats.created + moduleStats.created,
+    filesSkipped: architectureStats.skipped + moduleStats.skipped
+  });
+  finishingSpinner.stop("Success");
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("frontend-init").description("Initialize frontend architecture").version("1.0.0");
+program.command("init").action(initCommand);
+program.parse();
+//# sourceMappingURL=cli.js.map