@reliverse/dler 2.0.6 → 2.0.7

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

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

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

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

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

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

@@ -1,148 +0,0 @@
-// 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.");
-  }
-};