@reliverse/dler 2.0.0 → 2.0.1

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

@@ -0,0 +1,227 @@
+// apps/dler/src/cmds/integrate/integrations/nextjs.ts
+
+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 type { IntegrationContext, TempDirectory } from "../types";
+import { createIntegrationTempDir } from "../utils/temp";
+import { BaseIntegration } from "./base";
+
+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"];
+
+  private tempDir?: TempDirectory;
+
+  async install(context: IntegrationContext): Promise<void> {
+    logger.info("🔧 Installing Next.js integration...");
+
+    // Create temp directory for Next.js setup
+    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",
+    );
+
+    // Create Next.js app in temp directory
+    logger.info("📦 Creating Next.js app in temp directory...");
+    await Bun.$`bunx create-next-app@latest . --yes`
+      .cwd(nextjsTempPath)
+      .quiet();
+
+    // Modify tsconfig.json to use ~/ instead of @/
+    await this.updateTsConfig(nextjsTempPath);
+
+    // Copy files to target
+    await this.copyFilesToTarget(nextjsTempPath, context);
+
+    // Install dependencies
+    await this.installDependencies(context);
+
+    // Update package.json scripts
+    await this.updatePackageJsonScripts(context);
+  }
+
+  async configure(context: IntegrationContext): Promise<void> {
+    logger.info("⚙️ Configuring Next.js...");
+
+    // Create next.config.js if it doesn't exist
+    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);
+    }
+
+    // Create tailwind.config.ts if it doesn't exist
+    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("✅ Next.js configuration complete");
+  }
+
+  async postInstall(context: IntegrationContext): Promise<void> {
+    logger.info("🔧 Verifying Next.js installation...");
+
+    try {
+      // Check if Next.js is properly installed
+      await Bun.$`bun next --version`.cwd(context.targetPath).quiet();
+      logger.success("✅ Next.js is ready to use");
+      logger.info("🚀 Run 'bun dev' to start the development server");
+    } catch (error) {
+      logger.warn("⚠️ Next.js verification failed, but installation completed");
+      if (context.verbose) {
+        logger.debug(`Error: ${error}`);
+      }
+    }
+  }
+
+  private async updateTsConfig(tempPath: string): Promise<void> {
+    const tsconfigPath = join(tempPath, "tsconfig.json");
+
+    if (existsSync(tsconfigPath)) {
+      const tsconfig = await Bun.file(tsconfigPath).json();
+
+      // Replace @/* with ~/* in paths
+      if (tsconfig.compilerOptions?.paths) {
+        const newPaths: Record<string, string[]> = {};
+        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);
+    }
+  }
+
+  private async copyFilesToTarget(
+    tempPath: string,
+    context: IntegrationContext,
+  ): Promise<void> {
+    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(`📄 Copied ${file}`);
+      }
+    }
+  }
+
+  private async copyFileOrDir(src: string, dest: string): Promise<void> {
+    const stat = await Bun.file(src).stat();
+
+    if (stat.isDirectory()) {
+      // Copy directory recursively
+      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);
+
+        // Ensure destination directory exists
+        mkdirSync(dirname(destFile), { recursive: true });
+
+        // Copy file
+        const content = await Bun.file(srcFile).arrayBuffer();
+        await Bun.write(destFile, content);
+      }
+    } else {
+      // Copy single file
+      mkdirSync(dirname(dest), { recursive: true });
+      const content = await Bun.file(src).arrayBuffer();
+      await Bun.write(dest, content);
+    }
+  }
+
+  private async updatePackageJsonScripts(
+    context: IntegrationContext,
+  ): Promise<void> {
+    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("📝 Updated package.json scripts");
+    } catch (error) {
+      logger.warn("⚠️ Failed to update package.json scripts");
+      if (context.verbose) {
+        logger.debug(`Error: ${error}`);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,45 @@
+// apps/dler/src/cmds/integrate/integrations/registry.ts
+
+import { logger } from "@reliverse/dler-logger";
+import type { Integration } from "../types";
+import { NextJsIntegration } from "./nextjs";
+import { UltraciteIntegration } from "./ultracite";
+
+const INTEGRATIONS: Record<string, () => Integration> = {
+  ultracite: () => new UltraciteIntegration(),
+  nextjs: () => new NextJsIntegration(),
+};
+
+export function getIntegration(name: string): Integration | null {
+  const integrationFactory = INTEGRATIONS[name.toLowerCase()];
+
+  if (!integrationFactory) {
+    logger.error(`❌ Unknown integration: ${name}`);
+    logger.info(`Available integrations: ${listIntegrations().join(", ")}`);
+    return null;
+  }
+
+  return integrationFactory();
+}
+
+export function listIntegrations(): string[] {
+  return Object.keys(INTEGRATIONS);
+}
+
+export function validateIntegrationNames(names: string[]): {
+  valid: string[];
+  invalid: string[];
+} {
+  const valid: string[] = [];
+  const invalid: string[] = [];
+
+  for (const name of names) {
+    if (INTEGRATIONS[name.toLowerCase()]) {
+      valid.push(name);
+    } else {
+      invalid.push(name);
+    }
+  }
+
+  return { valid, invalid };
+}

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

@@ -0,0 +1,53 @@
+// apps/dler/src/cmds/integrate/integrations/ultracite.ts
+
+import { logger } from "@reliverse/dler-logger";
+import type { IntegrationContext } from "../types";
+import {
+  createBiomeConfig,
+  findBiomeConfig,
+  updateBiomeConfig,
+} from "../utils/biome";
+import { BaseIntegration } from "./base";
+
+export class UltraciteIntegration extends BaseIntegration {
+  name = "ultracite";
+  description =
+    "Ultracite preset for Biome (highly opinionated linter and formatter)";
+  dependencies: string[] = [];
+  devDependencies = ["@biomejs/biome", "ultracite"];
+
+  async install(context: IntegrationContext): Promise<void> {
+    logger.info("🔧 Installing Ultracite integration...");
+    await this.installDependencies(context);
+  }
+
+  async configure(context: IntegrationContext): Promise<void> {
+    logger.info("⚙️ Configuring Biome with Ultracite preset...");
+
+    const biomeConfig = await findBiomeConfig(context.targetPath);
+
+    if (biomeConfig.exists && biomeConfig.content) {
+      // Update existing biome.json
+      await updateBiomeConfig(biomeConfig.path, biomeConfig.content);
+      logger.success("✅ Updated existing biome.json with Ultracite preset");
+    } else {
+      // Create new biome.json
+      await createBiomeConfig(biomeConfig.path);
+      logger.success("✅ Created new biome.json with Ultracite preset");
+    }
+  }
+
+  async postInstall(context: IntegrationContext): Promise<void> {
+    logger.info("🔧 Running Biome check to verify configuration...");
+
+    try {
+      await Bun.$`bun biome check --version`.cwd(context.targetPath).quiet();
+      logger.success("✅ Biome is properly configured and ready to use");
+    } catch (error) {
+      logger.warn("⚠️ Biome check failed, but configuration was created");
+      if (context.verbose) {
+        logger.debug(`Error: ${error}`);
+      }
+    }
+  }
+}

package/src/cmds/integrate/types.ts

@@ -0,0 +1,48 @@
+// apps/dler/src/cmds/integrate/types.ts
+
+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[];
+
+  // Lifecycle hooks
+  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/src/cmds/integrate/utils/biome.ts

@@ -0,0 +1,173 @@
+// apps/dler/src/cmds/integrate/utils/biome.ts
+
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { writeJsonFile } from "@reliverse/dler-helpers";
+import { logger } from "@reliverse/dler-logger";
+import { hasWorkspaces, readPackageJSON } from "@reliverse/dler-pkg-tsc";
+import type { BiomeConfig } from "../types";
+
+export const findBiomeConfig = async (
+  startDir: string,
+): Promise<BiomeConfig> => {
+  let currentDir = resolve(startDir);
+  let depth = 0;
+  const maxDepth = 3;
+
+  while (depth <= maxDepth) {
+    const biomePath = join(currentDir, "biome.json");
+
+    if (existsSync(biomePath)) {
+      try {
+        const content = await Bun.file(biomePath).json();
+        return {
+          path: biomePath,
+          exists: true,
+          content,
+        };
+      } catch {
+        // If we can't read the file, continue searching
+      }
+    }
+
+    const parentDir = resolve(currentDir, "..");
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+    depth++;
+  }
+
+  // No biome.json found, determine where to create it
+  const monorepoRoot = await findMonorepoRoot(startDir);
+  const targetPath = monorepoRoot || startDir;
+
+  return {
+    path: join(targetPath, "biome.json"),
+    exists: false,
+  };
+};
+
+const findMonorepoRoot = async (startDir: string): Promise<string | null> => {
+  let currentDir = resolve(startDir);
+
+  while (currentDir !== "/") {
+    const pkgPath = join(currentDir, "package.json");
+
+    if (existsSync(pkgPath)) {
+      const pkg = await readPackageJSON(currentDir);
+
+      if (pkg && hasWorkspaces(pkg)) {
+        return currentDir;
+      }
+    }
+
+    const parentDir = resolve(currentDir, "..");
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+
+  return null;
+};
+
+export const createBiomeConfig = async (
+  configPath: string,
+  integrationType?: string,
+): Promise<void> => {
+  logger.info(`📝 Creating biome.json at ${configPath}`);
+
+  const baseConfig = {
+    $schema: "./node_modules/@biomejs/biome/configuration_schema.json",
+    extends: ["ultracite"],
+    files: {
+      includes: [
+        "**",
+        "!**/.js",
+        "!**/.d.ts",
+        "!**/_generated",
+        "!**/.next",
+        "!**/.react-email",
+        "!**/.source",
+        "!**/.turbo",
+        "!**/.vercel",
+        "!**/.wrangler",
+        "!**/.zed",
+        "!**/dev-dist",
+        "!**/dist-*",
+        "!**/dist",
+        "!**/drizzle/migrations",
+        "!**/node_modules",
+      ],
+      ignoreUnknown: false,
+    },
+    linter: {
+      enabled: true,
+      rules: {
+        recommended: true,
+        // Add integration-specific rules if needed
+        ...(integrationType === "nextjs" && {
+          a11y: {
+            useHtmlLang: "warn",
+            noHeaderScope: "warn",
+          },
+        }),
+      },
+    },
+    formatter: {
+      enabled: true,
+      indentStyle: "space",
+      indentWidth: 2,
+      lineWidth: 80,
+    },
+    javascript: {
+      globals: ["Bun"],
+      formatter: {
+        enabled: true,
+        lineEnding: "lf",
+        jsxQuoteStyle: "double",
+        quoteProperties: "asNeeded",
+        trailingCommas: "all",
+        lineWidth: 80,
+        indentWidth: 2,
+        indentStyle: "space",
+        semicolons: "always",
+        arrowParentheses: "always",
+        bracketSpacing: true,
+        bracketSameLine: false,
+        quoteStyle: "double",
+        attributePosition: "auto",
+      },
+    },
+    assist: {
+      enabled: true,
+      actions: {
+        source: {
+          organizeImports: "on",
+        },
+      },
+    },
+    vcs: {
+      enabled: false,
+      clientKind: "git",
+      useIgnoreFile: false,
+    },
+  };
+
+  await writeJsonFile(configPath, baseConfig);
+};
+
+export const updateBiomeConfig = async (
+  configPath: string,
+  content: any,
+): Promise<void> => {
+  logger.info(`📝 Updating biome.json at ${configPath}`);
+
+  // Ensure ultracite is in extends array
+  if (!content.extends || !Array.isArray(content.extends)) {
+    content.extends = [];
+  }
+
+  if (!content.extends.includes("ultracite")) {
+    content.extends.unshift("ultracite");
+  }
+
+  await writeJsonFile(configPath, content);
+};

package/src/cmds/integrate/utils/context.ts

@@ -0,0 +1,148 @@
+// apps/dler/src/cmds/integrate/utils/context.ts
+
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { logger } from "@reliverse/dler-logger";
+import {
+  getWorkspacePatterns,
+  hasWorkspaces,
+  readPackageJSON,
+} from "@reliverse/dler-pkg-tsc";
+import { askQuestion } from "@reliverse/dler-prompt";
+import type { PackageInfo, ProjectContext } from "../types";
+
+export const detectProjectContext = async (
+  cwd?: string,
+): Promise<ProjectContext> => {
+  const startDir = resolve(cwd ?? process.cwd());
+  const monorepoRoot = await findMonorepoRoot(startDir);
+
+  if (monorepoRoot) {
+    logger.info("🔍 Detected monorepo project");
+    const packages = await getWorkspacePackages(monorepoRoot);
+
+    return {
+      type: "monorepo",
+      rootPath: monorepoRoot,
+      targetPath: monorepoRoot, // Will be updated when package is selected
+      packages,
+    };
+  }
+
+  logger.info("🔍 Detected standalone project");
+  return {
+    type: "single-repo",
+    rootPath: startDir,
+    targetPath: startDir,
+  };
+};
+
+const findMonorepoRoot = async (startDir: string): Promise<string | null> => {
+  let currentDir = resolve(startDir);
+
+  while (currentDir !== "/") {
+    const pkgPath = join(currentDir, "package.json");
+
+    if (existsSync(pkgPath)) {
+      const pkg = await readPackageJSON(currentDir);
+
+      if (pkg && hasWorkspaces(pkg)) {
+        return currentDir;
+      }
+    }
+
+    const parentDir = resolve(currentDir, "..");
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+
+  return null;
+};
+
+const getWorkspacePackages = async (
+  monorepoRoot: string,
+): Promise<PackageInfo[]> => {
+  const rootPkg = await readPackageJSON(monorepoRoot);
+  if (!rootPkg) {
+    throw new Error("❌ Could not read root package.json");
+  }
+
+  const patterns = getWorkspacePatterns(rootPkg);
+  if (!patterns.length) {
+    throw new Error("❌ No workspace patterns found in package.json");
+  }
+
+  const packages: PackageInfo[] = [];
+  const seenPaths = new Set<string>();
+
+  for (const pattern of patterns) {
+    const glob = new Bun.Glob(pattern);
+    const matches = glob.scanSync({ cwd: monorepoRoot, onlyFiles: false });
+
+    for (const match of matches) {
+      const packagePath = resolve(monorepoRoot, match);
+
+      if (seenPaths.has(packagePath)) continue;
+      seenPaths.add(packagePath);
+
+      const pkgInfo = await resolvePackageInfo(packagePath);
+      if (pkgInfo) {
+        packages.push(pkgInfo);
+      }
+    }
+  }
+
+  return packages;
+};
+
+const resolvePackageInfo = async (
+  packagePath: string,
+): Promise<PackageInfo | null> => {
+  try {
+    const packageJsonPath = join(packagePath, "package.json");
+    if (!existsSync(packageJsonPath)) return null;
+
+    const packageJson = await readPackageJSON(packagePath);
+    if (!packageJson || !packageJson.name) return null;
+
+    return {
+      name: packageJson.name,
+      path: packagePath,
+      packageJson,
+    };
+  } catch {
+    return null;
+  }
+};
+
+export const selectTargetPackage = async (
+  packages: PackageInfo[],
+): Promise<PackageInfo> => {
+  if (packages.length === 0) {
+    throw new Error("❌ No packages found in workspace");
+  }
+
+  if (packages.length === 1) {
+    logger.info(`📦 Using package: ${packages[0]?.name}`);
+    return packages[0]!;
+  }
+
+  logger.info("\n📦 Available packages:");
+  packages.forEach((pkg, index) => {
+    logger.log(`  ${index + 1}. ${pkg.name}`);
+  });
+
+  while (true) {
+    const answer = await askQuestion(
+      `Select target package (1-${packages.length})`,
+      "1",
+    );
+
+    const index = parseInt(answer, 10) - 1;
+    if (index >= 0 && index < packages.length) {
+      return packages[index]!;
+    }
+
+    logger.error("❌ Invalid selection. Please try again.");
+  }
+};