@reliverse/dler 1.7.153 → 2.0.1

package/dist/cmds/init/impl/utils.js

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

package/dist/cmds/init/impl/validators.d.ts

@@ -0,0 +1,4 @@
+import type { ValidationResult } from "./types.js";
+export declare const validatePackageName: (name: string) => ValidationResult;
+export declare const validateMonorepoName: (name: string) => ValidationResult;
+export declare const validateVersion: (version: string) => ValidationResult;

package/dist/cmds/init/impl/validators.js

@@ -0,0 +1,42 @@
+export const validatePackageName = (name) => {
+  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) => {
+  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) => {
+  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/dist/cmds/integrate/cmd.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+declare const _default: any;
+export default _default;

package/dist/cmds/integrate/cmd.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env bun
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg
+} from "@reliverse/dler-launcher";
+import { logger } from "@reliverse/dler-logger";
+import { runIntegrate } from "./impl.js";
+const integrateCmd = async (args) => {
+  try {
+    const options = {
+      x: args.x,
+      target: args.target,
+      verbose: args.verbose || false,
+      cwd: args.cwd
+    };
+    await runIntegrate(options);
+  } catch (error) {
+    logger.error("\n\u274C 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/dist/cmds/integrate/impl.d.ts

@@ -0,0 +1,7 @@
+export interface IntegrateOptions {
+    x: string;
+    target?: string;
+    verbose: boolean;
+    cwd?: string;
+}
+export declare const runIntegrate: (options: IntegrateOptions) => Promise<void>;

package/dist/cmds/integrate/impl.js

@@ -0,0 +1,127 @@
+import { logger } from "@reliverse/dler-logger";
+import {
+  getIntegration,
+  validateIntegrationNames
+} from "./integrations/registry.js";
+import { detectProjectContext, selectTargetPackage } from "./utils/context.js";
+import { createTempDirectory } from "./utils/temp.js";
+export const runIntegrate = async (options) => {
+  try {
+    if (typeof process.versions.bun === "undefined") {
+      logger.error("\u274C This command requires Bun runtime. Sorry.");
+      process.exit(1);
+    }
+    const integrationNames = options.x.split(",").map((name) => name.trim()).filter(Boolean);
+    if (integrationNames.length === 0) {
+      logger.error(
+        "\u274C No integrations specified. Use --x to specify integrations (e.g., --x nextjs,ultracite)"
+      );
+      process.exit(1);
+    }
+    const { valid, invalid } = validateIntegrationNames(integrationNames);
+    if (invalid.length > 0) {
+      logger.error(`\u274C Invalid integrations: ${invalid.join(", ")}`);
+      logger.info(`Available integrations: ${valid.join(", ")}`);
+      process.exit(1);
+    }
+    logger.info("\u{1F50D} Detecting project context...");
+    const projectContext = await detectProjectContext(options.cwd);
+    let targetPath = projectContext.targetPath;
+    let selectedPackage = projectContext.selectedPackage;
+    if (projectContext.type === "monorepo") {
+      if (options.target) {
+        const targetPkg = projectContext.packages?.find(
+          (pkg) => pkg.name === options.target || pkg.name.endsWith(options.target)
+        );
+        if (!targetPkg) {
+          logger.error(`\u274C 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 {
+        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(`\u{1F4E6} Target package: ${selectedPackage?.name ?? "root"}`);
+    }
+    const tempDir = await createTempDirectory();
+    const integrationContext = {
+      targetPath,
+      isMonorepo: projectContext.type === "monorepo",
+      monorepoRoot: projectContext.type === "monorepo" ? projectContext.rootPath : void 0,
+      packageName: selectedPackage?.name,
+      verbose: options.verbose,
+      tempDir
+    };
+    const results = await runIntegrations(integrationNames, integrationContext);
+    logger.info("\u{1F4E6} Installing dependencies...");
+    await Bun.$`bun install`.cwd(targetPath).quiet();
+    await tempDir.cleanup();
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    if (successful.length > 0) {
+      logger.success(
+        `
+\u2705 Successfully integrated: ${successful.map((r) => r.name).join(", ")}`
+      );
+    }
+    if (failed.length > 0) {
+      logger.error(
+        `
+\u274C Failed integrations: ${failed.map((r) => r.name).join(", ")}`
+      );
+      process.exit(1);
+    }
+    logger.success("\n\u{1F389} All integrations completed successfully!");
+  } catch (error) {
+    logger.error("\n\u274C Integration failed:");
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+    process.exit(1);
+  }
+};
+const runIntegrations = async (integrationNames, context) => {
+  const results = [];
+  for (const name of integrationNames) {
+    logger.info(`
+\u{1F527} Processing ${name} integration...`);
+    try {
+      const integration = getIntegration(name);
+      if (!integration) {
+        results.push({ name, success: false, error: "Integration not found" });
+        continue;
+      }
+      const isValid = await integration.validate(context);
+      if (!isValid) {
+        results.push({
+          name,
+          success: true,
+          error: "Already installed, skipped"
+        });
+        continue;
+      }
+      await integration.install(context);
+      await integration.configure(context);
+      await integration.postInstall(context);
+      results.push({ name, success: true });
+      logger.success(`\u2705 ${name} integration completed`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`\u274C ${name} integration failed: ${errorMessage}`);
+      results.push({ name, success: false, error: errorMessage });
+    }
+  }
+  return results;
+};

package/dist/cmds/integrate/integrations/base.d.ts

@@ -0,0 +1,13 @@
+import type { Integration, IntegrationContext } from "../types.js";
+export declare abstract class BaseIntegration implements Integration {
+    abstract name: string;
+    abstract description: string;
+    abstract dependencies: string[];
+    abstract devDependencies: string[];
+    validate(_context: IntegrationContext): Promise<boolean>;
+    abstract install(context: IntegrationContext): Promise<void>;
+    abstract configure(context: IntegrationContext): Promise<void>;
+    postInstall(_context: IntegrationContext): Promise<void>;
+    protected isAlreadyInstalled(context: IntegrationContext): Promise<boolean>;
+    protected installDependencies(context: IntegrationContext): Promise<void>;
+}

package/dist/cmds/integrate/integrations/base.js

@@ -0,0 +1,41 @@
+import { logger } from "@reliverse/dler-logger";
+export class BaseIntegration {
+  async validate(_context) {
+    logger.debug(`\u{1F50D} Validating ${this.name} integration...`);
+    if (await this.isAlreadyInstalled(_context)) {
+      logger.warn(
+        `\u26A0\uFE0F ${this.name} appears to be already installed. Skipping...`
+      );
+      return false;
+    }
+    return true;
+  }
+  async postInstall(_context) {
+    logger.debug(`\u{1F527} Running post-install for ${this.name}...`);
+  }
+  async isAlreadyInstalled(context) {
+    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;
+    }
+  }
+  async installDependencies(context) {
+    const { targetPath } = context;
+    if (this.dependencies.length > 0) {
+      logger.info(`\u{1F4E6} Installing ${this.name} dependencies...`);
+      const deps = this.dependencies.join(" ");
+      await Bun.$`bun add ${deps}`.cwd(targetPath).quiet();
+    }
+    if (this.devDependencies.length > 0) {
+      logger.info(`\u{1F4E6} Installing ${this.name} dev dependencies...`);
+      const devDeps = this.devDependencies.join(" ");
+      await Bun.$`bun add -D ${devDeps}`.cwd(targetPath).quiet();
+    }
+  }
+}

package/dist/cmds/integrate/integrations/nextjs.d.ts

@@ -0,0 +1,16 @@
+import type { IntegrationContext } from "../types.js";
+import { BaseIntegration } from "./base.js";
+export declare class NextJsIntegration extends BaseIntegration {
+    name: string;
+    description: string;
+    dependencies: string[];
+    devDependencies: string[];
+    private tempDir?;
+    install(context: IntegrationContext): Promise<void>;
+    configure(context: IntegrationContext): Promise<void>;
+    postInstall(context: IntegrationContext): Promise<void>;
+    private updateTsConfig;
+    private copyFilesToTarget;
+    private copyFileOrDir;
+    private updatePackageJsonScripts;
+}

package/dist/cmds/integrate/integrations/nextjs.js

@@ -0,0 +1,167 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { writeJsonFile, writeTextFile } from "@reliverse/dler-helpers";
+import { logger } from "@reliverse/dler-logger";
+import { createIntegrationTempDir } from "../utils/temp.js";
+import { BaseIntegration } from "./base.js";
+export class NextJsIntegration extends BaseIntegration {
+  name = "nextjs";
+  description = "Next.js React framework with App Router, TypeScript, and Tailwind CSS";
+  dependencies = ["next", "react", "react-dom"];
+  devDependencies = ["@types/react", "@types/react-dom", "typescript"];
+  tempDir;
+  async install(context) {
+    logger.info("\u{1F527} Installing Next.js integration...");
+    this.tempDir = context.tempDir;
+    if (!this.tempDir) {
+      throw new Error("Temp directory not provided for Next.js integration");
+    }
+    const nextjsTempPath = await createIntegrationTempDir(
+      this.tempDir,
+      "nextjs"
+    );
+    logger.info("\u{1F4E6} Creating Next.js app in temp directory...");
+    await Bun.$`bunx create-next-app@latest . --yes`.cwd(nextjsTempPath).quiet();
+    await this.updateTsConfig(nextjsTempPath);
+    await this.copyFilesToTarget(nextjsTempPath, context);
+    await this.installDependencies(context);
+    await this.updatePackageJsonScripts(context);
+  }
+  async configure(context) {
+    logger.info("\u2699\uFE0F Configuring Next.js...");
+    const nextConfigPath = join(context.targetPath, "next.config.js");
+    if (!existsSync(nextConfigPath)) {
+      const nextConfig = `/** @type {import('next').NextConfig} */
+const nextConfig = {
+  experimental: {
+    turbo: {
+      rules: {
+        '*.svg': {
+          loaders: ['@svgr/webpack'],
+          as: '*.js',
+        },
+      },
+    },
+  },
+};
+
+module.exports = nextConfig;`;
+      await writeTextFile(nextConfigPath, nextConfig);
+    }
+    const tailwindConfigPath = join(context.targetPath, "tailwind.config.ts");
+    if (!existsSync(tailwindConfigPath)) {
+      const tailwindConfig = `import type { Config } from "tailwindcss";
+
+const config: Config = {
+  content: [
+    "./pages/**/*.{js,ts,jsx,tsx,mdx}",
+    "./components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./app/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+    extend: {
+      backgroundImage: {
+        "gradient-radial": "radial-gradient(var(--tw-gradient-stops))",
+        "gradient-conic":
+          "conic-gradient(from 180deg at 50% 50%, var(--tw-gradient-stops))",
+      },
+    },
+  },
+  plugins: [],
+};
+export default config;`;
+      await writeTextFile(tailwindConfigPath, tailwindConfig);
+    }
+    logger.success("\u2705 Next.js configuration complete");
+  }
+  async postInstall(context) {
+    logger.info("\u{1F527} Verifying Next.js installation...");
+    try {
+      await Bun.$`bun next --version`.cwd(context.targetPath).quiet();
+      logger.success("\u2705 Next.js is ready to use");
+      logger.info("\u{1F680} Run 'bun dev' to start the development server");
+    } catch (error) {
+      logger.warn("\u26A0\uFE0F Next.js verification failed, but installation completed");
+      if (context.verbose) {
+        logger.debug(`Error: ${error}`);
+      }
+    }
+  }
+  async updateTsConfig(tempPath) {
+    const tsconfigPath = join(tempPath, "tsconfig.json");
+    if (existsSync(tsconfigPath)) {
+      const tsconfig = await Bun.file(tsconfigPath).json();
+      if (tsconfig.compilerOptions?.paths) {
+        const newPaths = {};
+        for (const [key, value] of Object.entries(
+          tsconfig.compilerOptions.paths
+        )) {
+          const newKey = key.replace("@/*", "~/*");
+          newPaths[newKey] = Array.isArray(value) ? value : [value];
+        }
+        tsconfig.compilerOptions.paths = newPaths;
+      }
+      await writeJsonFile(tsconfigPath, tsconfig);
+    }
+  }
+  async copyFilesToTarget(tempPath, context) {
+    const filesToCopy = [
+      "app",
+      "public",
+      "next.config.js",
+      "next.config.ts",
+      "tailwind.config.ts",
+      "postcss.config.js",
+      "tsconfig.json"
+    ];
+    for (const file of filesToCopy) {
+      const srcPath = join(tempPath, file);
+      const destPath = join(context.targetPath, file);
+      if (existsSync(srcPath)) {
+        await this.copyFileOrDir(srcPath, destPath);
+        logger.debug(`\u{1F4C4} Copied ${file}`);
+      }
+    }
+  }
+  async copyFileOrDir(src, dest) {
+    const stat = await Bun.file(src).stat();
+    if (stat.isDirectory()) {
+      const glob = new Bun.Glob("**/*");
+      const files = Array.from(glob.scanSync({ cwd: src, onlyFiles: true }));
+      for (const file of files) {
+        const srcFile = join(src, file);
+        const destFile = join(dest, file);
+        mkdirSync(dirname(destFile), { recursive: true });
+        const content = await Bun.file(srcFile).arrayBuffer();
+        await Bun.write(destFile, content);
+      }
+    } else {
+      mkdirSync(dirname(dest), { recursive: true });
+      const content = await Bun.file(src).arrayBuffer();
+      await Bun.write(dest, content);
+    }
+  }
+  async updatePackageJsonScripts(context) {
+    const packageJsonPath = join(context.targetPath, "package.json");
+    try {
+      const packageJson = await Bun.file(packageJsonPath).json();
+      const nextjsScripts = {
+        dev: "next dev",
+        build: "next build",
+        start: "next start",
+        lint: "next lint"
+      };
+      packageJson.scripts = {
+        ...packageJson.scripts,
+        ...nextjsScripts
+      };
+      await writeJsonFile(packageJsonPath, packageJson);
+      logger.debug("\u{1F4DD} Updated package.json scripts");
+    } catch (error) {
+      logger.warn("\u26A0\uFE0F Failed to update package.json scripts");
+      if (context.verbose) {
+        logger.debug(`Error: ${error}`);
+      }
+    }
+  }
+}

package/dist/cmds/integrate/integrations/registry.d.ts

@@ -0,0 +1,7 @@
+import type { Integration } from "../types.js";
+export declare function getIntegration(name: string): Integration | null;
+export declare function listIntegrations(): string[];
+export declare function validateIntegrationNames(names: string[]): {
+    valid: string[];
+    invalid: string[];
+};

package/dist/cmds/integrate/integrations/registry.js

@@ -0,0 +1,31 @@
+import { logger } from "@reliverse/dler-logger";
+import { NextJsIntegration } from "./nextjs.js";
+import { UltraciteIntegration } from "./ultracite.js";
+const INTEGRATIONS = {
+  ultracite: () => new UltraciteIntegration(),
+  nextjs: () => new NextJsIntegration()
+};
+export function getIntegration(name) {
+  const integrationFactory = INTEGRATIONS[name.toLowerCase()];
+  if (!integrationFactory) {
+    logger.error(`\u274C Unknown integration: ${name}`);
+    logger.info(`Available integrations: ${listIntegrations().join(", ")}`);
+    return null;
+  }
+  return integrationFactory();
+}
+export function listIntegrations() {
+  return Object.keys(INTEGRATIONS);
+}
+export function validateIntegrationNames(names) {
+  const valid = [];
+  const invalid = [];
+  for (const name of names) {
+    if (INTEGRATIONS[name.toLowerCase()]) {
+      valid.push(name);
+    } else {
+      invalid.push(name);
+    }
+  }
+  return { valid, invalid };
+}

package/dist/cmds/integrate/integrations/ultracite.d.ts

@@ -0,0 +1,11 @@
+import type { IntegrationContext } from "../types.js";
+import { BaseIntegration } from "./base.js";
+export declare class UltraciteIntegration extends BaseIntegration {
+    name: string;
+    description: string;
+    dependencies: string[];
+    devDependencies: string[];
+    install(context: IntegrationContext): Promise<void>;
+    configure(context: IntegrationContext): Promise<void>;
+    postInstall(context: IntegrationContext): Promise<void>;
+}

package/dist/cmds/integrate/integrations/ultracite.js

@@ -0,0 +1,40 @@
+import { logger } from "@reliverse/dler-logger";
+import {
+  createBiomeConfig,
+  findBiomeConfig,
+  updateBiomeConfig
+} from "../utils/biome.js";
+import { BaseIntegration } from "./base.js";
+export class UltraciteIntegration extends BaseIntegration {
+  name = "ultracite";
+  description = "Ultracite preset for Biome (highly opinionated linter and formatter)";
+  dependencies = [];
+  devDependencies = ["@biomejs/biome", "ultracite"];
+  async install(context) {
+    logger.info("\u{1F527} Installing Ultracite integration...");
+    await this.installDependencies(context);
+  }
+  async configure(context) {
+    logger.info("\u2699\uFE0F Configuring Biome with Ultracite preset...");
+    const biomeConfig = await findBiomeConfig(context.targetPath);
+    if (biomeConfig.exists && biomeConfig.content) {
+      await updateBiomeConfig(biomeConfig.path, biomeConfig.content);
+      logger.success("\u2705 Updated existing biome.json with Ultracite preset");
+    } else {
+      await createBiomeConfig(biomeConfig.path);
+      logger.success("\u2705 Created new biome.json with Ultracite preset");
+    }
+  }
+  async postInstall(context) {
+    logger.info("\u{1F527} Running Biome check to verify configuration...");
+    try {
+      await Bun.$`bun biome check --version`.cwd(context.targetPath).quiet();
+      logger.success("\u2705 Biome is properly configured and ready to use");
+    } catch (error) {
+      logger.warn("\u26A0\uFE0F Biome check failed, but configuration was created");
+      if (context.verbose) {
+        logger.debug(`Error: ${error}`);
+      }
+    }
+  }
+}

package/dist/cmds/integrate/types.d.ts

@@ -0,0 +1,39 @@
+export interface IntegrationContext {
+    targetPath: string;
+    isMonorepo: boolean;
+    monorepoRoot?: string;
+    packageName?: string;
+    verbose: boolean;
+    tempDir: TempDirectory;
+}
+export interface Integration {
+    name: string;
+    description: string;
+    dependencies: string[];
+    devDependencies: string[];
+    validate(context: IntegrationContext): Promise<boolean>;
+    install(context: IntegrationContext): Promise<void>;
+    configure(context: IntegrationContext): Promise<void>;
+    postInstall(context: IntegrationContext): Promise<void>;
+}
+export interface ProjectContext {
+    type: "monorepo" | "single-repo";
+    rootPath: string;
+    targetPath: string;
+    packages?: PackageInfo[];
+    selectedPackage?: PackageInfo;
+}
+export interface PackageInfo {
+    name: string;
+    path: string;
+    packageJson: any;
+}
+export interface BiomeConfig {
+    path: string;
+    exists: boolean;
+    content?: any;
+}
+export interface TempDirectory {
+    path: string;
+    cleanup: () => Promise<void>;
+}

package/dist/cmds/integrate/utils/biome.d.ts

@@ -0,0 +1,4 @@
+import type { BiomeConfig } from "../types.js";
+export declare const findBiomeConfig: (startDir: string) => Promise<BiomeConfig>;
+export declare const createBiomeConfig: (configPath: string, integrationType?: string) => Promise<void>;
+export declare const updateBiomeConfig: (configPath: string, content: any) => Promise<void>;