@reliverse/dler 2.0.0 → 2.0.1

package/src/cmds/init/impl/prompts.ts

@@ -0,0 +1,137 @@
+import { logger } from "@reliverse/dler-logger";
+import { askQuestion } from "@reliverse/dler-prompt";
+import { DEFAULT_LICENSE, DEFAULT_VERSION, WORKSPACES } from "./config";
+import type { MonorepoConfig, PackageInfo } from "./types";
+import { createFullPath, fileExists, getWorkspaceScope } from "./utils";
+import {
+  validateMonorepoName,
+  validatePackageName,
+  validateVersion,
+} from "./validators";
+
+export const promptMonorepoConfig = async (): Promise<MonorepoConfig> => {
+  logger.info("🚀 Bun Monorepo Bootstrapper\n");
+
+  // Try to read existing root package.json to avoid re-asking known values
+  const rootPath = process.cwd();
+  const rootPackageJsonPath = createFullPath(rootPath, "package.json");
+  const hasRootPackageJson = await fileExists(rootPackageJsonPath);
+  const existingRoot: Record<string, unknown> | null = hasRootPackageJson
+    ? await Bun.file(rootPackageJsonPath)
+        .json()
+        .catch(() => null)
+    : null;
+
+  let name = "";
+  let isValidName = false;
+
+  if (existingRoot && typeof existingRoot.name === "string") {
+    name = existingRoot.name;
+    isValidName = true;
+  } else {
+    while (!isValidName) {
+      name = await askQuestion("Monorepo name", "my-monorepo");
+      const validation = validateMonorepoName(name);
+
+      if (!validation.valid) {
+        logger.error(`❌ ${validation.error}`);
+        continue;
+      }
+
+      isValidName = true;
+    }
+  }
+
+  const description =
+    existingRoot && typeof existingRoot.description === "string"
+      ? (existingRoot.description as string)
+      : await askQuestion("Description", "A Bun monorepo project");
+
+  let version = "";
+  let isValidVersion = false;
+
+  if (existingRoot && typeof existingRoot.version === "string") {
+    version = existingRoot.version;
+    isValidVersion = true;
+  } else {
+    while (!isValidVersion) {
+      version = await askQuestion("Version", DEFAULT_VERSION);
+      const validation = validateVersion(version);
+
+      if (!validation.valid) {
+        logger.error(`❌ ${validation.error}`);
+        continue;
+      }
+
+      isValidVersion = true;
+    }
+  }
+
+  const author =
+    existingRoot && typeof (existingRoot as any).author === "string"
+      ? ((existingRoot as any).author as string)
+      : await askQuestion("Author", "");
+  const license =
+    existingRoot && typeof (existingRoot as any).license === "string"
+      ? ((existingRoot as any).license as string)
+      : await askQuestion("License", DEFAULT_LICENSE);
+
+  const packages = await promptPackages();
+
+  return {
+    name,
+    description,
+    version,
+    author,
+    license,
+    packages,
+    rootPath,
+  };
+};
+
+const promptPackages = async (): Promise<PackageInfo[]> => {
+  const packages: PackageInfo[] = [];
+
+  logger.info("\n📦 Package Configuration");
+  logger.info(
+    "Enter package names (one per prompt). Press Enter with empty input to finish.\n",
+  );
+
+  let continueAdding = true;
+  let packageIndex = 1;
+
+  while (continueAdding) {
+    const packageName = await askQuestion(
+      `Package ${packageIndex} name (or press Enter to finish)`,
+    );
+
+    if (!packageName) {
+      continueAdding = false;
+      continue;
+    }
+
+    const validation = validatePackageName(packageName);
+
+    if (!validation.valid) {
+      logger.error(`❌ ${validation.error}`);
+      continue;
+    }
+
+    const workspace = await askQuestion(
+      "Workspace directory",
+      WORKSPACES.PACKAGES,
+    );
+    const scope = getWorkspaceScope(workspace);
+
+    packages.push({
+      name: packageName,
+      workspace,
+      scope,
+    });
+
+    logger.success(`✅ Added ${scope}${packageName}\n`);
+    packageIndex++;
+  }
+
+  return packages;
+};

package/src/cmds/init/impl/types.ts

@@ -0,0 +1,25 @@
+export type PackageInfo = {
+  name: string;
+  workspace: string;
+  scope: string;
+};
+
+export type MonorepoConfig = {
+  name: string;
+  description: string;
+  version: string;
+  author: string;
+  license: string;
+  packages: PackageInfo[];
+  rootPath: string;
+};
+
+export type CatalogDependency = {
+  name: string;
+  version: string;
+};
+
+export type ValidationResult = {
+  valid: boolean;
+  error?: string;
+};

package/src/cmds/init/impl/utils.ts

@@ -0,0 +1,17 @@
+import { exists, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+export const getWorkspaceScope = (workspace: string): string =>
+  `@${workspace.charAt(0)}/`;
+
+export const ensureDir = async (path: string): Promise<void> => {
+  const dirExists = await exists(path);
+  if (!dirExists) {
+    await mkdir(path, { recursive: true });
+  }
+};
+
+export const fileExists = async (path: string): Promise<boolean> =>
+  exists(path);
+
+export const createFullPath = (...paths: string[]): string => join(...paths);

package/src/cmds/init/impl/validators.ts

@@ -0,0 +1,55 @@
+import type { ValidationResult } from "./types";
+
+export const validatePackageName = (name: string): ValidationResult => {
+  if (!name || name.trim().length === 0) {
+    return { valid: false, error: "Package name cannot be empty" };
+  }
+
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    return {
+      valid: false,
+      error:
+        "Package name must contain only lowercase letters, numbers, and hyphens",
+    };
+  }
+
+  if (name.startsWith("-") || name.endsWith("-")) {
+    return {
+      valid: false,
+      error: "Package name cannot start or end with a hyphen",
+    };
+  }
+
+  return { valid: true };
+};
+
+export const validateMonorepoName = (name: string): ValidationResult => {
+  if (!name || name.trim().length === 0) {
+    return { valid: false, error: "Monorepo name cannot be empty" };
+  }
+
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    return {
+      valid: false,
+      error:
+        "Monorepo name must contain only lowercase letters, numbers, and hyphens",
+    };
+  }
+
+  return { valid: true };
+};
+
+export const validateVersion = (version: string): ValidationResult => {
+  if (!version || version.trim().length === 0) {
+    return { valid: false, error: "Version cannot be empty" };
+  }
+
+  if (!/^\d+\.\d+\.\d+(-[a-z0-9.-]+)?$/.test(version)) {
+    return {
+      valid: false,
+      error: "Version must follow semantic versioning (e.g., 1.0.0)",
+    };
+  }
+
+  return { valid: true };
+};

package/src/cmds/integrate/cmd.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env bun
+
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg,
+} from "@reliverse/dler-launcher";
+import { logger } from "@reliverse/dler-logger";
+import type { IntegrateOptions } from "./impl";
+import { runIntegrate } from "./impl";
+
+const integrateCmd = async (args: any): Promise<void> => {
+  try {
+    const options: IntegrateOptions = {
+      x: args.x,
+      target: args.target,
+      verbose: args.verbose || false,
+      cwd: args.cwd,
+    };
+
+    await runIntegrate(options);
+  } catch (error) {
+    logger.error("\n❌ Integration failed:");
+
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+
+    process.exit(1);
+  }
+};
+
+const integrateCmdArgs = defineCmdArgs({
+  x: {
+    type: "string",
+    description:
+      "Integration(s) to install (comma-separated, e.g., 'nextjs,ultracite')",
+    required: true,
+  },
+  target: {
+    type: "string",
+    description:
+      "Target package in monorepo (optional, will prompt if not specified)",
+  },
+  verbose: {
+    type: "boolean",
+    description: "Verbose mode for detailed logging (default: false)",
+  },
+  cwd: {
+    type: "string",
+    description: "Working directory (default: current directory)",
+  },
+});
+
+const integrateCmdCfg = defineCmdCfg({
+  name: "integrate",
+  description:
+    "Automatically install and configure integrations like Next.js and Ultracite/Biome. Supports both monorepo and single-repo contexts.",
+  examples: [
+    "dler integrate --x nextjs",
+    "dler integrate --x ultracite",
+    "dler integrate --x nextjs,ultracite",
+    "dler integrate --x nextjs --target my-app",
+    "dler integrate --x ultracite --verbose",
+    "dler integrate --x nextjs --cwd /path/to/project",
+    "",
+    "# Available integrations:",
+    "# - nextjs: Next.js React framework with App Router, TypeScript, and Tailwind CSS",
+    "# - ultracite: Ultracite preset for Biome (highly opinionated linter and formatter)",
+    "",
+    "# Monorepo usage:",
+    "# The command will automatically detect if you're in a monorepo and prompt you to",
+    "# select a target package, or you can specify one with --target",
+    "",
+    "# Single-repo usage:",
+    "# The command will install integrations directly into the current directory",
+  ],
+});
+
+export default defineCmd(integrateCmd, integrateCmdArgs, integrateCmdCfg);

package/src/cmds/integrate/impl.ts

@@ -0,0 +1,204 @@
+// apps/dler/src/cmds/integrate/impl.ts
+
+import { logger } from "@reliverse/dler-logger";
+import {
+  getIntegration,
+  validateIntegrationNames,
+} from "./integrations/registry";
+import type { IntegrationContext } from "./types";
+import { detectProjectContext, selectTargetPackage } from "./utils/context";
+import { createTempDirectory } from "./utils/temp";
+
+export interface IntegrateOptions {
+  x: string;
+  target?: string;
+  verbose: boolean;
+  cwd?: string;
+}
+
+export const runIntegrate = async (
+  options: IntegrateOptions,
+): Promise<void> => {
+  try {
+    // Check if running in Bun
+    if (typeof process.versions.bun === "undefined") {
+      logger.error("❌ This command requires Bun runtime. Sorry.");
+      process.exit(1);
+    }
+
+    // Parse integration names
+    const integrationNames = options.x
+      .split(",")
+      .map((name) => name.trim())
+      .filter(Boolean);
+
+    if (integrationNames.length === 0) {
+      logger.error(
+        "❌ No integrations specified. Use --x to specify integrations (e.g., --x nextjs,ultracite)",
+      );
+      process.exit(1);
+    }
+
+    // Validate integration names
+    const { valid, invalid } = validateIntegrationNames(integrationNames);
+
+    if (invalid.length > 0) {
+      logger.error(`❌ Invalid integrations: ${invalid.join(", ")}`);
+      logger.info(`Available integrations: ${valid.join(", ")}`);
+      process.exit(1);
+    }
+
+    // Detect project context
+    logger.info("🔍 Detecting project context...");
+    const projectContext = await detectProjectContext(options.cwd);
+
+    // Resolve target directory
+    let targetPath = projectContext.targetPath;
+    let selectedPackage = projectContext.selectedPackage;
+
+    if (projectContext.type === "monorepo") {
+      if (options.target) {
+        // Find specified target package
+        const targetPkg = projectContext.packages?.find(
+          (pkg) =>
+            pkg.name === options.target || pkg.name.endsWith(options.target!),
+        );
+
+        if (!targetPkg) {
+          logger.error(`❌ Target package '${options.target}' not found`);
+          logger.info(
+            `Available packages: ${projectContext.packages?.map((p) => p.name).join(", ")}`,
+          );
+          process.exit(1);
+        }
+
+        selectedPackage = targetPkg;
+        targetPath = targetPkg.path;
+      } else {
+        // Prompt user to select target package
+        if (projectContext.packages && projectContext.packages.length > 1) {
+          selectedPackage = await selectTargetPackage(projectContext.packages);
+          targetPath = selectedPackage.path;
+        } else if (
+          projectContext.packages &&
+          projectContext.packages.length === 1
+        ) {
+          selectedPackage = projectContext.packages[0];
+          targetPath = selectedPackage!.path;
+        }
+      }
+
+      logger.info(`📦 Target package: ${selectedPackage?.name ?? "root"}`);
+    }
+
+    // Create temp directory for integrations that need it
+    const tempDir = await createTempDirectory();
+
+    // Create integration context
+    const integrationContext: IntegrationContext = {
+      targetPath,
+      isMonorepo: projectContext.type === "monorepo",
+      monorepoRoot:
+        projectContext.type === "monorepo"
+          ? projectContext.rootPath
+          : undefined,
+      packageName: selectedPackage?.name,
+      verbose: options.verbose,
+      tempDir,
+    };
+
+    // Run integrations
+    const results = await runIntegrations(integrationNames, integrationContext);
+
+    // Install dependencies
+    logger.info("📦 Installing dependencies...");
+    await Bun.$`bun install`.cwd(targetPath).quiet();
+
+    // Clean up temp directory
+    await tempDir.cleanup();
+
+    // Report results
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+
+    if (successful.length > 0) {
+      logger.success(
+        `\n✅ Successfully integrated: ${successful.map((r) => r.name).join(", ")}`,
+      );
+    }
+
+    if (failed.length > 0) {
+      logger.error(
+        `\n❌ Failed integrations: ${failed.map((r) => r.name).join(", ")}`,
+      );
+      process.exit(1);
+    }
+
+    logger.success("\n🎉 All integrations completed successfully!");
+  } catch (error) {
+    logger.error("\n❌ Integration failed:");
+
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+
+    process.exit(1);
+  }
+};
+
+interface IntegrationResult {
+  name: string;
+  success: boolean;
+  error?: string;
+}
+
+const runIntegrations = async (
+  integrationNames: string[],
+  context: IntegrationContext,
+): Promise<IntegrationResult[]> => {
+  const results: IntegrationResult[] = [];
+
+  for (const name of integrationNames) {
+    logger.info(`\n🔧 Processing ${name} integration...`);
+
+    try {
+      const integration = getIntegration(name);
+      if (!integration) {
+        results.push({ name, success: false, error: "Integration not found" });
+        continue;
+      }
+
+      // Validate integration
+      const isValid = await integration.validate(context);
+      if (!isValid) {
+        results.push({
+          name,
+          success: true,
+          error: "Already installed, skipped",
+        });
+        continue;
+      }
+
+      // Install integration
+      await integration.install(context);
+
+      // Configure integration
+      await integration.configure(context);
+
+      // Run post-install hooks
+      await integration.postInstall(context);
+
+      results.push({ name, success: true });
+      logger.success(`✅ ${name} integration completed`);
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      logger.error(`❌ ${name} integration failed: ${errorMessage}`);
+      results.push({ name, success: false, error: errorMessage });
+    }
+  }
+
+  return results;
+};

package/src/cmds/integrate/integrations/base.ts

@@ -0,0 +1,69 @@
+// apps/dler/src/cmds/integrate/integrations/base.ts
+
+import { logger } from "@reliverse/dler-logger";
+import type { Integration, IntegrationContext } from "../types";
+
+export abstract class BaseIntegration implements Integration {
+  abstract name: string;
+  abstract description: string;
+  abstract dependencies: string[];
+  abstract devDependencies: string[];
+
+  async validate(_context: IntegrationContext): Promise<boolean> {
+    logger.debug(`🔍 Validating ${this.name} integration...`);
+
+    // Check if already installed
+    if (await this.isAlreadyInstalled(_context)) {
+      logger.warn(
+        `⚠️ ${this.name} appears to be already installed. Skipping...`,
+      );
+      return false;
+    }
+
+    return true;
+  }
+
+  abstract install(context: IntegrationContext): Promise<void>;
+  abstract configure(context: IntegrationContext): Promise<void>;
+
+  async postInstall(_context: IntegrationContext): Promise<void> {
+    logger.debug(`🔧 Running post-install for ${this.name}...`);
+    // Default implementation - can be overridden
+  }
+
+  protected async isAlreadyInstalled(
+    context: IntegrationContext,
+  ): Promise<boolean> {
+    // Default implementation - check if dependencies exist in package.json
+    try {
+      const packageJsonPath = `${context.targetPath}/package.json`;
+      const packageJson = await Bun.file(packageJsonPath).json();
+
+      const allDeps = [...this.dependencies, ...this.devDependencies];
+      return allDeps.some(
+        (dep) =>
+          packageJson.dependencies?.[dep] || packageJson.devDependencies?.[dep],
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  protected async installDependencies(
+    context: IntegrationContext,
+  ): Promise<void> {
+    const { targetPath } = context;
+
+    if (this.dependencies.length > 0) {
+      logger.info(`📦 Installing ${this.name} dependencies...`);
+      const deps = this.dependencies.join(" ");
+      await Bun.$`bun add ${deps}`.cwd(targetPath).quiet();
+    }
+
+    if (this.devDependencies.length > 0) {
+      logger.info(`📦 Installing ${this.name} dev dependencies...`);
+      const devDeps = this.devDependencies.join(" ");
+      await Bun.$`bun add -D ${devDeps}`.cwd(targetPath).quiet();
+    }
+  }
+}