@reliverse/dler 2.0.0 → 2.0.2

package/dist/cmds/integrate/utils/biome.js

@@ -0,0 +1,140 @@
+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";
+export const findBiomeConfig = async (startDir) => {
+  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 {
+      }
+    }
+    const parentDir = resolve(currentDir, "..");
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+    depth++;
+  }
+  const monorepoRoot = await findMonorepoRoot(startDir);
+  const targetPath = monorepoRoot || startDir;
+  return {
+    path: join(targetPath, "biome.json"),
+    exists: false
+  };
+};
+const findMonorepoRoot = async (startDir) => {
+  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, integrationType) => {
+  logger.info(`\u{1F4DD} 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, content) => {
+  logger.info(`\u{1F4DD} Updating biome.json at ${configPath}`);
+  if (!content.extends || !Array.isArray(content.extends)) {
+    content.extends = [];
+  }
+  if (!content.extends.includes("ultracite")) {
+    content.extends.unshift("ultracite");
+  }
+  await writeJsonFile(configPath, content);
+};

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

@@ -0,0 +1,3 @@
+import type { PackageInfo, ProjectContext } from "../types.js";
+export declare const detectProjectContext: (cwd?: string) => Promise<ProjectContext>;
+export declare const selectTargetPackage: (packages: PackageInfo[]) => Promise<PackageInfo>;

package/dist/cmds/integrate/utils/context.js

@@ -0,0 +1,111 @@
+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";
+export const detectProjectContext = async (cwd) => {
+  const startDir = resolve(cwd ?? process.cwd());
+  const monorepoRoot = await findMonorepoRoot(startDir);
+  if (monorepoRoot) {
+    logger.info("\u{1F50D} 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("\u{1F50D} Detected standalone project");
+  return {
+    type: "single-repo",
+    rootPath: startDir,
+    targetPath: startDir
+  };
+};
+const findMonorepoRoot = async (startDir) => {
+  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) => {
+  const rootPkg = await readPackageJSON(monorepoRoot);
+  if (!rootPkg) {
+    throw new Error("\u274C Could not read root package.json");
+  }
+  const patterns = getWorkspacePatterns(rootPkg);
+  if (!patterns.length) {
+    throw new Error("\u274C No workspace patterns found in package.json");
+  }
+  const packages = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  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) => {
+  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) => {
+  if (packages.length === 0) {
+    throw new Error("\u274C No packages found in workspace");
+  }
+  if (packages.length === 1) {
+    logger.info(`\u{1F4E6} Using package: ${packages[0]?.name}`);
+    return packages[0];
+  }
+  logger.info("\n\u{1F4E6} 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("\u274C Invalid selection. Please try again.");
+  }
+};

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

@@ -0,0 +1,3 @@
+import type { TempDirectory } from "../types.js";
+export declare const createTempDirectory: () => Promise<TempDirectory>;
+export declare const createIntegrationTempDir: (tempDir: TempDirectory, integrationName: string) => Promise<string>;

package/dist/cmds/integrate/utils/temp.js

@@ -0,0 +1,36 @@
+import { existsSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { logger } from "@reliverse/dler-logger";
+import { ensureDir } from "../../init/impl/utils.js";
+export const createTempDirectory = async () => {
+  const timestamp = Date.now();
+  const tempPath = join(
+    homedir(),
+    ".reliverse",
+    "dler",
+    "temp",
+    "integrate",
+    timestamp.toString()
+  );
+  await ensureDir(tempPath);
+  logger.debug(`\u{1F4C1} Created temp directory: ${tempPath}`);
+  return {
+    path: tempPath,
+    cleanup: async () => {
+      try {
+        if (existsSync(tempPath)) {
+          rmSync(tempPath, { recursive: true, force: true });
+          logger.debug(`\u{1F9F9} Cleaned up temp directory: ${tempPath}`);
+        }
+      } catch (error) {
+        logger.warn(`\u26A0\uFE0F Failed to clean up temp directory: ${error}`);
+      }
+    }
+  };
+};
+export const createIntegrationTempDir = async (tempDir, integrationName) => {
+  const integrationPath = join(tempDir.path, `${integrationName}-temp`);
+  await ensureDir(integrationPath);
+  return integrationPath;
+};

package/dist/cmds/perf/analysis/bundle.d.ts

@@ -0,0 +1,20 @@
+import type { BundleAnalysisResult } from "../types.js";
+export interface BundleAnalysisOptions {
+    target: string;
+    verbose?: boolean;
+    includeSourceMaps?: boolean;
+    analyzeDependencies?: boolean;
+}
+export declare class BundleAnalyzer {
+    private options;
+    constructor(options: BundleAnalysisOptions);
+    analyze(): Promise<BundleAnalysisResult>;
+    private findBundleFiles;
+    private analyzeFile;
+    private getFileType;
+    private extractModules;
+    private findDuplicates;
+    private calculateCompressionPotential;
+}
+export declare const analyzeBundle: (options: BundleAnalysisOptions) => Promise<BundleAnalysisResult>;
+export declare const createBundleAnalyzer: (options: BundleAnalysisOptions) => BundleAnalyzer;

package/dist/cmds/perf/analysis/bundle.js

@@ -0,0 +1,225 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { extname, join, resolve } from "node:path";
+import { logger } from "@reliverse/dler-logger";
+export class BundleAnalyzer {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async analyze() {
+    const startTime = Date.now();
+    const { target, verbose } = this.options;
+    if (verbose) {
+      logger.info(`\u{1F50D} Analyzing bundle: ${target}`);
+    }
+    const targetPath = resolve(target);
+    if (!existsSync(targetPath)) {
+      throw new Error(`Target not found: ${target}`);
+    }
+    const stat = statSync(targetPath);
+    let files = [];
+    if (stat.isDirectory()) {
+      files = await this.findBundleFiles(targetPath);
+    } else {
+      files = [targetPath];
+    }
+    if (files.length === 0) {
+      throw new Error(`No bundle files found in: ${target}`);
+    }
+    if (verbose) {
+      logger.info(`   Found ${files.length} bundle files`);
+    }
+    const fileSizes = [];
+    const modules = [];
+    const duplicates = [];
+    for (const file of files) {
+      const fileSize = await this.analyzeFile(file);
+      fileSizes.push(fileSize);
+      if (this.options.analyzeDependencies) {
+        const fileModules = await this.extractModules(file);
+        modules.push(...fileModules);
+      }
+    }
+    fileSizes.sort((a, b) => b.size - a.size);
+    if (this.options.analyzeDependencies) {
+      const duplicateMap = this.findDuplicates(modules);
+      duplicates.push(...duplicateMap);
+    }
+    const totalSize = fileSizes.reduce((sum, file) => sum + file.size, 0);
+    const fileCount = fileSizes.length;
+    const compressionPotential = this.calculateCompressionPotential(files);
+    fileSizes.forEach((file) => {
+      file.percentage = file.size / totalSize * 100;
+    });
+    const analysisTime = Date.now() - startTime;
+    if (verbose) {
+      logger.info(`   Analysis completed in ${analysisTime}ms`);
+    }
+    return {
+      target,
+      totalSize,
+      fileCount,
+      largestFiles: fileSizes.slice(0, 10),
+      // Top 10
+      modules: modules.slice(0, 20),
+      // Top 20 modules
+      duplicates: duplicates.slice(0, 10),
+      // Top 10 duplicates
+      compressionPotential,
+      analysisTime
+    };
+  }
+  async findBundleFiles(dir) {
+    const bundleExtensions = [".js", ".mjs", ".cjs", ".ts", ".jsx", ".tsx"];
+    const files = [];
+    try {
+      const glob = new Bun.Glob("**/*");
+      const matches = glob.scanSync({ cwd: dir, onlyFiles: true });
+      for (const match of matches) {
+        const fullPath = join(dir, match);
+        const ext = extname(match);
+        if (bundleExtensions.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      logger.warn(`Error scanning directory ${dir}:`, error);
+    }
+    return files;
+  }
+  async analyzeFile(filePath) {
+    const stat = statSync(filePath);
+    const ext = extname(filePath);
+    return {
+      path: filePath,
+      size: stat.size,
+      percentage: 0,
+      // Will be calculated later
+      type: this.getFileType(ext)
+    };
+  }
+  getFileType(extension) {
+    const typeMap = {
+      ".js": "JavaScript",
+      ".mjs": "ES Module",
+      ".cjs": "CommonJS",
+      ".ts": "TypeScript",
+      ".jsx": "React JSX",
+      ".tsx": "React TSX",
+      ".json": "JSON",
+      ".css": "CSS",
+      ".scss": "SCSS",
+      ".sass": "Sass",
+      ".less": "Less",
+      ".html": "HTML",
+      ".svg": "SVG",
+      ".png": "PNG",
+      ".jpg": "JPEG",
+      ".jpeg": "JPEG",
+      ".gif": "GIF",
+      ".webp": "WebP",
+      ".woff": "WOFF",
+      ".woff2": "WOFF2",
+      ".ttf": "TrueType",
+      ".eot": "EOT",
+      ".map": "Source Map"
+    };
+    return typeMap[extension] ?? "Unknown";
+  }
+  async extractModules(filePath) {
+    const modules = [];
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+      const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+      const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+      const dependencies = /* @__PURE__ */ new Set();
+      let match;
+      while ((match = importRegex.exec(content)) !== null) {
+        dependencies.add(match[1]);
+      }
+      while ((match = requireRegex.exec(content)) !== null) {
+        dependencies.add(match[1]);
+      }
+      while ((match = dynamicImportRegex.exec(content)) !== null) {
+        dependencies.add(match[1]);
+      }
+      for (const dep of dependencies) {
+        const isExternal = !dep.startsWith(".") && !dep.startsWith("/");
+        modules.push({
+          name: dep,
+          size: 0,
+          // Would need to resolve actual size
+          percentage: 0,
+          dependencies: [],
+          isExternal
+        });
+      }
+    } catch (error) {
+      logger.warn(`Error extracting modules from ${filePath}:`, error);
+    }
+    return modules;
+  }
+  findDuplicates(modules) {
+    const moduleMap = /* @__PURE__ */ new Map();
+    for (const module of modules) {
+      const key = module.name;
+      const existing = moduleMap.get(key);
+      if (existing) {
+        existing.count++;
+        existing.totalSize += module.size;
+        existing.locations.push(module.name);
+      } else {
+        moduleMap.set(key, {
+          count: 1,
+          totalSize: module.size,
+          locations: [module.name]
+        });
+      }
+    }
+    const duplicates = [];
+    for (const [name, info] of moduleMap) {
+      if (info.count > 1) {
+        duplicates.push({
+          name,
+          count: info.count,
+          totalSize: info.totalSize,
+          locations: info.locations
+        });
+      }
+    }
+    return duplicates.sort((a, b) => b.totalSize - a.totalSize);
+  }
+  calculateCompressionPotential(files) {
+    let totalSize = 0;
+    let compressibleSize = 0;
+    for (const file of files) {
+      const stat = statSync(file);
+      const ext = extname(file);
+      totalSize += stat.size;
+      const compressibleExtensions = [
+        ".js",
+        ".ts",
+        ".jsx",
+        ".tsx",
+        ".json",
+        ".css",
+        ".html",
+        ".svg"
+      ];
+      if (compressibleExtensions.includes(ext)) {
+        compressibleSize += stat.size;
+      }
+    }
+    if (totalSize === 0) return 0;
+    const estimatedCompression = compressibleSize * 0.7;
+    return estimatedCompression / totalSize * 100;
+  }
+}
+export const analyzeBundle = async (options) => {
+  const analyzer = new BundleAnalyzer(options);
+  return analyzer.analyze();
+};
+export const createBundleAnalyzer = (options) => {
+  return new BundleAnalyzer(options);
+};

package/dist/cmds/perf/analysis/filesystem.d.ts

@@ -0,0 +1,27 @@
+import type { FileSystemAnalysisResult } from "../types.js";
+export interface FileSystemAnalysisOptions {
+    target: string;
+    verbose?: boolean;
+    maxDepth?: number;
+    includeHidden?: boolean;
+    excludePatterns?: string[];
+}
+export declare class FileSystemAnalyzer {
+    private options;
+    private fileCount;
+    private totalSize;
+    private directoryCount;
+    private maxDepth;
+    private files;
+    private directories;
+    private fileTypes;
+    constructor(options: FileSystemAnalysisOptions);
+    analyze(): Promise<FileSystemAnalysisResult>;
+    private analyzeFile;
+    private analyzeDirectory;
+    private shouldExclude;
+    private getFileType;
+    private calculateCompressionPotential;
+}
+export declare const analyzeFileSystem: (options: FileSystemAnalysisOptions) => Promise<FileSystemAnalysisResult>;
+export declare const createFileSystemAnalyzer: (options: FileSystemAnalysisOptions) => FileSystemAnalyzer;