@reliverse/dler 2.0.6 → 2.0.8

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

@@ -1,137 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,82 +0,0 @@
-#!/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

@@ -1,204 +0,0 @@
-// 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

@@ -1,69 +0,0 @@
-// 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();
-    }
-  }
-}