@reliverse/dler 1.7.153 → 2.0.1

package/src/cmds/clean/presets.ts

@@ -0,0 +1,158 @@
+// apps/dler/src/cmds/clean/presets.ts
+
+import type { PresetCategory } from "./types";
+
+export const PRESET_CATEGORIES: Record<string, PresetCategory> = {
+  // Build artifacts (default, always included)
+  build: {
+    name: "build",
+    description: "Build artifacts and compiled output",
+    patterns: ["dist/", "dev-dist/", "target/"],
+    order: 1,
+  },
+
+  // Database
+  db: {
+    name: "db",
+    description: "Database generated files",
+    patterns: ["_generated/"],
+    order: 2,
+  },
+
+  // CMS
+  cms: {
+    name: "cms",
+    description: "CMS generated files",
+    patterns: [".basehub/"],
+    order: 3,
+  },
+
+  // Frontend
+  frontend: {
+    name: "frontend",
+    description: "Frontend framework build artifacts",
+    patterns: [".next/", ".nuxt/", ".expo/", "routeTree.gen.ts"],
+    order: 4,
+  },
+
+  // Documentation
+  docs: {
+    name: "docs",
+    description: "Documentation generated files",
+    patterns: [".source/"],
+    order: 5,
+  },
+
+  // Email
+  email: {
+    name: "email",
+    description: "Email template generated files",
+    patterns: [".react-email/"],
+    order: 6,
+  },
+
+  // Build tools
+  "build-tools": {
+    name: "build-tools",
+    description: "Build tool caches and artifacts",
+    patterns: [".turbo/", ".vercel/", ".wrangler/"],
+    order: 7,
+  },
+
+  // Dependencies (deleted last)
+  deps: {
+    name: "deps",
+    description: "Dependencies and lock files",
+    patterns: ["node_modules/"],
+    order: 10,
+  },
+};
+
+export const LOCK_FILE_PATTERNS = [
+  "bun.lock",
+  "yarn.lock",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+];
+
+export const parsePresets = (presetsString?: string): string[] => {
+  if (!presetsString) {
+    return [];
+  }
+
+  if (presetsString === "all") {
+    return Object.keys(PRESET_CATEGORIES);
+  }
+
+  return presetsString
+    .split(",")
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0);
+};
+
+export const parseCustomPatterns = (customString?: string): string[] => {
+  if (!customString) {
+    return [];
+  }
+
+  return customString
+    .split(",")
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0);
+};
+
+export const getPresetPatterns = (presets: string[]): string[] => {
+  const patterns: string[] = [];
+
+  for (const preset of presets) {
+    const category = PRESET_CATEGORIES[preset];
+    if (category) {
+      patterns.push(...category.patterns);
+    }
+  }
+
+  return patterns;
+};
+
+export const getPresetOrder = (presets: string[]): number[] =>
+  presets
+    .map((preset) => PRESET_CATEGORIES[preset]?.order ?? 999)
+    .sort((a, b) => a - b);
+
+export const getPresetDescription = (presets: string[]): string => {
+  const categories = presets
+    .map((preset) => PRESET_CATEGORIES[preset])
+    .filter(Boolean);
+
+  if (categories.length === 0) {
+    return "No valid presets selected";
+  }
+
+  if (categories.length === 1) {
+    return categories[0]!.description;
+  }
+
+  return categories.map((cat) => cat!.name).join(", ");
+};
+
+export const mergePatterns = (
+  presets: string[],
+  customPatterns: string[],
+): string[] => {
+  const presetPatterns = getPresetPatterns(presets);
+  const allPatterns = [...presetPatterns, ...customPatterns];
+
+  // Remove duplicates while preserving order
+  return [...new Set(allPatterns)];
+};
+
+export const validatePatterns = (
+  presets: string[],
+  customPatterns: string[],
+): void => {
+  if (presets.length === 0 && customPatterns.length === 0) {
+    throw new Error(
+      "❌ At least one of --presets or --custom must be provided",
+    );
+  }
+};

package/src/cmds/clean/types.ts

@@ -0,0 +1,71 @@
+// apps/dler/src/cmds/clean/types.ts
+
+export interface CleanOptions {
+  presets?: string;
+  custom?: string;
+  ignore?: string | string[];
+  cwd?: string;
+  subdirs?: boolean;
+  dryRun?: boolean;
+  force?: boolean;
+  verbose?: boolean;
+  deleteLockFiles?: boolean;
+  replaceExports?: boolean;
+  replaceExportsIgnorePackages?: string;
+}
+
+export interface FileMatch {
+  path: string;
+  size: number;
+  isDirectory: boolean;
+  category: string;
+}
+
+export interface CleanResult {
+  totalFiles: number;
+  totalSize: number;
+  deletedFiles: number;
+  deletedSize: number;
+  errors: CleanError[];
+  hasErrors: boolean;
+  results: PackageCleanResult[];
+}
+
+export interface PackageCleanResult {
+  package: PackageInfo;
+  files: FileMatch[];
+  deletedCount: number;
+  deletedSize: number;
+  errors: CleanError[];
+}
+
+export interface PackageInfo {
+  name: string;
+  path: string;
+  isRoot: boolean;
+}
+
+export interface CleanError {
+  path: string;
+  error: string;
+  package?: string;
+}
+
+export interface PresetCategory {
+  name: string;
+  description: string;
+  patterns: string[];
+  order: number; // Lower numbers are deleted first
+}
+
+export interface CleanSummary {
+  totalPackages: number;
+  processedPackages: number;
+  totalFiles: number;
+  totalSize: number;
+  deletedFiles: number;
+  deletedSize: number;
+  errors: CleanError[];
+  hasErrors: boolean;
+  results: PackageCleanResult[];
+}

package/src/cmds/init/cmd.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env bun
+
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg,
+} from "@reliverse/dler-launcher";
+import { logger } from "@reliverse/dler-logger";
+import { finalizePromptIO } from "@reliverse/dler-prompt";
+import { $ } from "bun";
+import {
+  generateAllPackages,
+  generateRootFiles,
+  generateRootPackageJson,
+} from "./impl/generators";
+import { promptMonorepoConfig } from "./impl/prompts";
+
+const initCmd = async (): Promise<void> => {
+  try {
+    const config = await promptMonorepoConfig();
+    await finalizePromptIO();
+
+    logger.info("\n🔨 Generating monorepo structure...\n");
+
+    await generateRootPackageJson(config);
+    await generateRootFiles(config);
+    await generateAllPackages(config);
+
+    logger.info("\n📦 Installing dependencies...\n");
+
+    await $`bun install`.cwd(config.rootPath);
+
+    logger.success("\n✅ Monorepo created successfully!");
+    logger.success(`\n📁 Location: ${config.rootPath}`);
+    logger.success("\nTo get started:");
+    logger.log(`  cd ${config.rootPath}`);
+    logger.log("  bun --filter '*' dev\n");
+  } catch (error) {
+    logger.error("\n❌ Error creating monorepo:");
+
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+
+    process.exit(1);
+  }
+};
+
+function getCurrentWorkingDirectory() {
+  return process.cwd();
+}
+
+const initCmdArgs = defineCmdArgs({
+  name: {
+    type: "string",
+    description: "Current working directory",
+    default: getCurrentWorkingDirectory(),
+  },
+});
+
+const initCmdCfg = defineCmdCfg({
+  name: "init",
+  description: "Initialize a new monorepo",
+});
+
+export default defineCmd(initCmd, initCmdArgs, initCmdCfg);

package/src/cmds/init/impl/config.ts

@@ -0,0 +1,105 @@
+import type { CatalogDependency } from "./types";
+
+export const DEFAULT_VERSION = "0.1.0";
+export const DEFAULT_LICENSE = "MIT";
+
+export const WORKSPACES = {
+  PACKAGES: "packages",
+  TSCONFIG: "packages/tsconfig",
+} as const;
+
+export const DEFAULT_CATALOG: readonly CatalogDependency[] = [
+  { name: "typescript", version: "^5.7.2" },
+  { name: "@types/bun", version: "^1.3.0" },
+] as const;
+
+export const TSCONFIG_PRESETS = {
+  base: {
+    $schema: "https://json.schemastore.org/tsconfig",
+    compilerOptions: {
+      lib: ["ESNext"],
+      target: "ESNext",
+      module: "ESNext",
+      moduleDetection: "force",
+      allowJs: true,
+      moduleResolution: "Bundler",
+      allowImportingTsExtensions: true,
+      verbatimModuleSyntax: true,
+      noEmit: true,
+      strict: true,
+      skipLibCheck: true,
+      noFallthroughCasesInSwitch: true,
+      noUnusedLocals: false,
+      noUnusedParameters: false,
+      noPropertyAccessFromIndexSignature: false,
+      esModuleInterop: true,
+      isolatedModules: true,
+    },
+  },
+  strict: {
+    $schema: "https://json.schemastore.org/tsconfig",
+    extends: "./base.json",
+    compilerOptions: {
+      noUncheckedIndexedAccess: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+    },
+  },
+} as const;
+
+export const ROOT_FILES = {
+  GITIGNORE: `# Dependencies
+node_modules/
+
+# Build outputs
+dist/
+out/
+*.tsbuildinfo
+
+# Environment
+.env
+.env*.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+`,
+  README: (name: string) => `# ${name}
+
+A Bun monorepo created with the monorepo bootstrapper.
+
+## Getting Started
+
+\`\`\`bash
+bun install
+\`\`\`
+
+## Workspaces
+
+This monorepo was generated by dler init. It uses bun workspaces to manage multiple packages.
+
+## Scripts
+
+Run scripts across all workspaces:
+
+\`\`\`bash
+bun --filter '*' <script>
+\`\`\`
+
+Run scripts for specific packages:
+
+\`\`\`bash
+bun --filter <package-name> <script>
+\`\`\`
+`,
+} as const;

package/src/cmds/init/impl/generators.ts

@@ -0,0 +1,220 @@
+import { writeJsonFile, writeTextFile } from "@reliverse/dler-helpers";
+import { logger } from "@reliverse/dler-logger";
+import {
+  DEFAULT_CATALOG,
+  ROOT_FILES,
+  TSCONFIG_PRESETS,
+  WORKSPACES,
+} from "./config";
+import type { MonorepoConfig, PackageInfo } from "./types";
+import {
+  createFullPath,
+  ensureDir,
+  fileExists,
+  getWorkspaceScope,
+} from "./utils";
+
+export const generateRootPackageJson = async (
+  config: MonorepoConfig,
+): Promise<void> => {
+  const packageJsonPath = createFullPath(config.rootPath, "package.json");
+  const alreadyExists = await fileExists(packageJsonPath);
+
+  if (alreadyExists) {
+    logger.info("📝 Updating existing root package.json...");
+    const existingContent = await Bun.file(packageJsonPath).json();
+
+    const workspaces = new Set<string>([
+      ...(existingContent.workspaces?.packages || []),
+      ...getWorkspacePatterns(config),
+    ]);
+
+    const catalog = {
+      ...(existingContent.workspaces?.catalog || {}),
+      ...Object.fromEntries(
+        DEFAULT_CATALOG.map((dep) => [dep.name, dep.version]),
+      ),
+    };
+
+    const updatedPackageJson = {
+      ...existingContent,
+      // Persist core metadata from current config (overwrite with user's latest answers)
+      name: config.name,
+      version: config.version,
+      description: config.description,
+      ...(config.author && { author: config.author }),
+      ...(config.license && { license: config.license }),
+      workspaces: {
+        ...existingContent.workspaces,
+        packages: Array.from(workspaces).sort(),
+        catalog,
+      },
+    };
+
+    await writeJsonFile(packageJsonPath, updatedPackageJson);
+  } else {
+    logger.info("📝 Creating root package.json...");
+    const packageJson = {
+      name: config.name,
+      version: config.version,
+      description: config.description,
+      private: true,
+      workspaces: {
+        packages: getWorkspacePatterns(config),
+        catalog: Object.fromEntries(
+          DEFAULT_CATALOG.map((dep) => [dep.name, dep.version]),
+        ),
+      },
+      scripts: {
+        check: "bun typecheck && bun lint && bun format",
+        typecheck: "tsc --noEmit",
+        lint: "biome check .",
+        "lint:fix": "biome check --write .",
+        format: "biome format --write .",
+      },
+      devDependencies: {
+        "@biomejs/biome": "catalog:",
+        typescript: "catalog:",
+        "@types/bun": "catalog:",
+      },
+      ...(config.author && { author: config.author }),
+      ...(config.license && { license: config.license }),
+    };
+
+    await writeJsonFile(packageJsonPath, packageJson);
+  }
+};
+
+const getWorkspacePatterns = (config: MonorepoConfig): string[] => {
+  const patterns = new Set<string>();
+
+  for (const pkg of config.packages) {
+    patterns.add(`${pkg.workspace}/*`);
+  }
+
+  return Array.from(patterns).sort();
+};
+
+export const generateRootFiles = async (
+  config: MonorepoConfig,
+): Promise<void> => {
+  logger.info("📄 Creating root files...");
+
+  const gitignorePath = createFullPath(config.rootPath, ".gitignore");
+  if (!(await fileExists(gitignorePath))) {
+    await writeTextFile(gitignorePath, ROOT_FILES.GITIGNORE);
+  }
+
+  const readmePath = createFullPath(config.rootPath, "README.md");
+  if (!(await fileExists(readmePath))) {
+    await writeTextFile(readmePath, ROOT_FILES.README(config.name));
+  }
+};
+
+export const generateTsconfigPackage = async (
+  config: MonorepoConfig,
+): Promise<void> => {
+  logger.info("📦 Creating tsconfig package...");
+
+  const tsconfigPath = createFullPath(config.rootPath, WORKSPACES.TSCONFIG);
+  await ensureDir(tsconfigPath);
+
+  const packageJsonPath = createFullPath(tsconfigPath, "package.json");
+  if (!(await fileExists(packageJsonPath))) {
+    const scope = getWorkspaceScope(WORKSPACES.PACKAGES);
+    const packageJson = {
+      name: `${scope}tsconfig`,
+      version: "0.0.0",
+      private: true,
+      description: "Shared TypeScript configuration",
+    };
+
+    await writeJsonFile(packageJsonPath, packageJson);
+  }
+
+  for (const [name, content] of Object.entries(TSCONFIG_PRESETS)) {
+    const presetPath = createFullPath(tsconfigPath, `${name}.json`);
+    if (!(await fileExists(presetPath))) {
+      await writeJsonFile(presetPath, content);
+    }
+  }
+};
+
+export const generatePackage = async (
+  config: MonorepoConfig,
+  pkg: PackageInfo,
+): Promise<void> => {
+  const packagePath = createFullPath(config.rootPath, pkg.workspace, pkg.name);
+
+  logger.info(`📦 Creating package ${pkg.scope}${pkg.name}...`);
+
+  await ensureDir(packagePath);
+
+  const packageJsonPath = createFullPath(packagePath, "package.json");
+  if (!(await fileExists(packageJsonPath))) {
+    const tsconfigScope = getWorkspaceScope(WORKSPACES.PACKAGES);
+    const packageJson = {
+      name: `${pkg.scope}${pkg.name}`,
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      exports: {
+        ".": {
+          types: "./src/mod.ts",
+          default: "./src/mod.ts",
+        },
+      },
+      scripts: {
+        dev: "bun src/mod.ts",
+      },
+      devDependencies: {
+        [`${tsconfigScope}tsconfig`]: "workspace:*",
+        typescript: "catalog:",
+        "@types/bun": "catalog:",
+      },
+    };
+
+    await writeJsonFile(packageJsonPath, packageJson);
+  }
+
+  const tsconfigPath = createFullPath(packagePath, "tsconfig.json");
+  if (!(await fileExists(tsconfigPath))) {
+    const tsconfigScope = getWorkspaceScope(WORKSPACES.PACKAGES);
+    const tsconfig = {
+      extends: `${tsconfigScope}tsconfig/strict.json`,
+      compilerOptions: {
+        rootDir: ".",
+        outDir: "./dist",
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist"],
+    };
+
+    await writeJsonFile(tsconfigPath, tsconfig);
+  }
+
+  const srcPath = createFullPath(packagePath, "src");
+  await ensureDir(srcPath);
+
+  const indexPath = createFullPath(srcPath, "index.ts");
+  if (!(await fileExists(indexPath))) {
+    const indexContent = `export const hello = (): string => {
+  return "Hello from ${pkg.scope}${pkg.name}!";
+};
+
+console.log(hello());
+`;
+
+    await writeTextFile(indexPath, indexContent);
+  }
+};
+
+export const generateAllPackages = async (
+  config: MonorepoConfig,
+): Promise<void> => {
+  await generateTsconfigPackage(config);
+
+  for (const pkg of config.packages) {
+    await generatePackage(config, pkg);
+  }
+};