@reliverse/dler 2.1.6 → 2.1.7

package/dist/cmds/integrate/cmd.js

@@ -1,66 +0,0 @@
-import { defineArgs, defineCommand } from "@reliverse/dler-launcher";
-import { logger } from "@reliverse/dler-logger";
-import { runIntegrate } from "./impl.js";
-export default defineCommand({
-  meta: {
-    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"
-    ]
-  },
-  args: defineArgs({
-    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)"
-    }
-  }),
-  run: 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);
-    }
-  }
-});

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

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

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

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

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

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

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

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

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

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

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

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

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