@reliverse/dler 1.7.119 → 1.7.121

package/bin/app/providers/cmd.js

@@ -1,299 +0,0 @@
-import path from "node:path";
-import { re } from "@reliverse/relico";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import {
-  cancel,
-  defineCommand,
-  intro,
-  isCancel,
-  outro,
-  selectPrompt,
-  spinner
-} from "@reliverse/rempts";
-import { DEFAULT_CONFIG } from "./better-t-stack/constants.js";
-import { createProject } from "./better-t-stack/helpers/project-generation/create-project.js";
-import { gatherConfig } from "./better-t-stack/prompts/config-prompts.js";
-import { getProjectName } from "./better-t-stack/prompts/project-name.js";
-import { trackProjectCreation } from "./better-t-stack/utils/analytics.js";
-import { displayConfig } from "./better-t-stack/utils/display-config.js";
-import { generateReproducibleCommand } from "./better-t-stack/utils/generate-reproducible-command.js";
-import { getLatestCLIVersion } from "./better-t-stack/utils/get-latest-cli-version.js";
-import { renderTitle } from "./better-t-stack/utils/render-title.js";
-import { getProvidedFlags, processAndValidateFlags } from "./better-t-stack/validation.js";
-async function handleDirectoryConflict(currentPathInput) {
-  while (true) {
-    const resolvedPath = path.resolve(process.cwd(), currentPathInput);
-    const dirExists = fs.pathExistsSync(resolvedPath);
-    const dirIsNotEmpty = dirExists && fs.readdirSync(resolvedPath).length > 0;
-    if (!dirIsNotEmpty) {
-      return { finalPathInput: currentPathInput, shouldClearDirectory: false };
-    }
-    relinka("warn", `Directory "${re.yellow(currentPathInput)}" already exists and is not empty.`);
-    const action = await selectPrompt({
-      title: "What would you like to do?",
-      options: [
-        {
-          value: "overwrite",
-          label: "Overwrite",
-          hint: "Empty the directory and create the project"
-        },
-        {
-          value: "merge",
-          label: "Merge",
-          hint: "Create project files inside, potentially overwriting conflicts"
-        },
-        {
-          value: "rename",
-          label: "Choose a different name/path",
-          hint: "Keep the existing directory and create a new one"
-        },
-        { value: "cancel", label: "Cancel", hint: "Abort the process" }
-      ],
-      defaultValue: "rename"
-    });
-    if (isCancel(action)) {
-      cancel(re.red("Operation cancelled."));
-      process.exit(0);
-    }
-    switch (action) {
-      case "overwrite":
-        return { finalPathInput: currentPathInput, shouldClearDirectory: true };
-      case "merge":
-        relinka(
-          "info",
-          `Proceeding into existing directory "${re.yellow(
-            currentPathInput
-          )}". Files may be overwritten.`
-        );
-        return {
-          finalPathInput: currentPathInput,
-          shouldClearDirectory: false
-        };
-      case "rename": {
-        relinka("info", "Please choose a different project name or path.");
-        const newPathInput = await getProjectName(void 0);
-        return await handleDirectoryConflict(newPathInput);
-      }
-      case "cancel":
-        cancel(re.red("Operation cancelled."));
-        process.exit(0);
-    }
-  }
-}
-async function setupProjectDirectory(finalPathInput, shouldClearDirectory) {
-  let finalResolvedPath;
-  let finalBaseName;
-  if (finalPathInput === ".") {
-    finalResolvedPath = process.cwd();
-    finalBaseName = path.basename(finalResolvedPath);
-  } else {
-    finalResolvedPath = path.resolve(process.cwd(), finalPathInput);
-    finalBaseName = path.basename(finalResolvedPath);
-  }
-  if (shouldClearDirectory) {
-    const s = spinner({
-      text: `Clearing directory "${finalResolvedPath}"...`
-    });
-    s.start(`Clearing directory "${finalResolvedPath}"...`);
-    try {
-      await fs.emptyDir(finalResolvedPath);
-      s.stop(`Directory "${finalResolvedPath}" cleared.`);
-    } catch (error) {
-      s.stop(re.red(`Failed to clear directory "${finalResolvedPath}".`));
-      relinka("error", String(error));
-      process.exit(1);
-    }
-  } else {
-    await fs.ensureDir(finalResolvedPath);
-  }
-  return { finalResolvedPath, finalBaseName };
-}
-async function createProjectHandler(input) {
-  const startTime = Date.now();
-  try {
-    renderTitle();
-    intro(re.magenta("Creating a new Better-T Stack project"));
-    let currentPathInput;
-    if (input.yes && input.projectName) {
-      currentPathInput = input.projectName;
-    } else if (input.yes) {
-      let defaultName = DEFAULT_CONFIG.relativePath;
-      let counter = 1;
-      while (fs.pathExistsSync(path.resolve(process.cwd(), defaultName)) && fs.readdirSync(path.resolve(process.cwd(), defaultName)).length > 0) {
-        defaultName = `${DEFAULT_CONFIG.projectName}-${counter}`;
-        counter++;
-      }
-      currentPathInput = defaultName;
-    } else {
-      currentPathInput = await getProjectName(input.projectName);
-    }
-    const { finalPathInput, shouldClearDirectory } = await handleDirectoryConflict(currentPathInput);
-    const { finalResolvedPath, finalBaseName } = await setupProjectDirectory(
-      finalPathInput,
-      shouldClearDirectory
-    );
-    const cliInput = {
-      ...input,
-      projectDirectory: input.projectName
-    };
-    const providedFlags = getProvidedFlags(cliInput);
-    const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
-    const { projectName: _projectNameFromFlags, ...otherFlags } = flagConfig;
-    if (!input.yes && Object.keys(otherFlags).length > 0) {
-      relinka("info", re.yellow("Using these pre-selected options:"));
-      relinka("log", displayConfig(otherFlags));
-      relinka("log", "");
-    }
-    let config;
-    if (input.yes) {
-      config = {
-        ...DEFAULT_CONFIG,
-        ...flagConfig,
-        projectName: finalBaseName,
-        projectDir: finalResolvedPath,
-        relativePath: finalPathInput
-      };
-      if (config.backend === "convex") {
-        relinka(
-          "info",
-          "Due to '--backend convex' flag, the following options have been automatically set: auth=false, database=none, orm=none, api=none, runtime=none, dbSetup=none, examples=todo"
-        );
-      } else if (config.backend === "none") {
-        relinka(
-          "info",
-          "Due to '--backend none', the following options have been automatically set: --auth=false, --database=none, --orm=none, --api=none, --runtime=none, --db-setup=none, --examples=none"
-        );
-      }
-      relinka("info", re.yellow("Using default/flag options (config prompts skipped):"));
-      relinka("log", displayConfig(config));
-      relinka("log", "");
-    } else {
-      config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
-    }
-    await createProject(config);
-    const reproducibleCommand = generateReproducibleCommand(config);
-    relinka(
-      "success",
-      re.blue(`You can reproduce this setup with the following command:
-${reproducibleCommand}`)
-    );
-    await trackProjectCreation(config);
-    const elapsedTimeInSeconds = ((Date.now() - startTime) / 1e3).toFixed(2);
-    outro(re.magenta(`Project created successfully in ${re.bold(elapsedTimeInSeconds)} seconds!`));
-  } catch (error) {
-    relinka("error", String(error));
-    process.exit(1);
-  }
-}
-export default defineCommand({
-  meta: {
-    name: "create-better-t-stack",
-    version: getLatestCLIVersion(),
-    description: "Create a new Better-T Stack project"
-  },
-  args: {
-    projectName: {
-      type: "string",
-      description: "Project name or path"
-    },
-    yes: {
-      type: "boolean",
-      description: "Use default configuration",
-      default: false
-    },
-    database: {
-      type: "string",
-      description: "Database type",
-      allowed: ["none", "sqlite", "postgres", "mysql", "mongodb"]
-    },
-    orm: {
-      type: "string",
-      description: "ORM type",
-      allowed: ["drizzle", "prisma", "mongoose", "none"]
-    },
-    auth: {
-      type: "boolean",
-      description: "Enable authentication"
-    },
-    frontend: {
-      type: "array",
-      description: "Frontend frameworks",
-      allowed: [
-        "tanstack-router",
-        "react-router",
-        "tanstack-start",
-        "next",
-        "nuxt",
-        "native-nativewind",
-        "native-unistyles",
-        "svelte",
-        "solid",
-        "none"
-      ]
-    },
-    addons: {
-      type: "array",
-      description: "Additional addons",
-      allowed: ["pwa", "tauri", "starlight", "biome", "husky", "turborepo", "none"]
-    },
-    examples: {
-      type: "array",
-      description: "Example templates",
-      allowed: ["todo", "ai", "none"]
-    },
-    git: {
-      type: "boolean",
-      description: "Initialize git repository"
-    },
-    packageManager: {
-      type: "string",
-      description: "Package manager",
-      allowed: ["npm", "pnpm", "bun"]
-    },
-    install: {
-      type: "boolean",
-      description: "Install dependencies"
-    },
-    dbSetup: {
-      type: "string",
-      description: "Database setup",
-      allowed: ["turso", "neon", "prisma-postgres", "mongodb-atlas", "supabase", "none"]
-    },
-    backend: {
-      type: "string",
-      description: "Backend framework",
-      allowed: ["hono", "express", "fastify", "next", "elysia", "convex", "none"]
-    },
-    runtime: {
-      type: "string",
-      description: "Runtime environment",
-      allowed: ["bun", "node", "workers", "none"]
-    },
-    api: {
-      type: "string",
-      description: "API type",
-      allowed: ["trpc", "orpc", "none"]
-    }
-  },
-  async run({ args }) {
-    const input = {
-      projectName: args.projectName,
-      yes: args.yes,
-      database: args.database,
-      orm: args.orm,
-      auth: args.auth,
-      frontend: args.frontend,
-      addons: args.addons,
-      examples: args.examples,
-      git: args.git,
-      packageManager: args.packageManager,
-      install: args.install,
-      dbSetup: args.dbSetup,
-      backend: args.backend,
-      runtime: args.runtime,
-      api: args.api
-    };
-    await createProjectHandler(input);
-  }
-});

package/bin/app/remdn/cmd.d.ts

@@ -1,35 +0,0 @@
-interface DirOptions {
-    /** File extensions to include (e.g. ".ts"). If omitted, include all. */
-    includeExt?: string[];
-    /** File extensions to exclude. */
-    excludeExt?: string[];
-}
-type DirConfig = Record<string, DirOptions>;
-type ExtMap = Record<string, [string, string, string]>;
-export interface ConfigRemdn {
-    title?: string;
-    output?: string;
-    dirs: DirConfig;
-    "ext-map"?: ExtMap;
-}
-export declare function scanDirectories(config?: ConfigRemdn, configPath?: string, outputPath?: string): Promise<void>;
-declare const _default: import("@reliverse/rempts").Command<{
-    mode: {
-        type: "string";
-        allowed: string[];
-        description: string;
-    };
-    configPath: {
-        type: "string";
-        description: string;
-    };
-    outputFilePath: {
-        type: "string";
-        description: string;
-    };
-    initConfig: {
-        type: "string";
-        description: string;
-    };
-}>;
-export default _default;

package/bin/app/remove/cmd.d.ts

@@ -1,60 +0,0 @@
-/**
- * USAGE EXAMPLES:
- * - dler remove package-name - removes a package
- * - dler rm package-name - removes a package (alias)
- * - dler uninstall package-name - removes a package (alias)
- * - dler remove --standalone - removes standalone dler installation
- */
-declare const _default: import("@reliverse/rempts").Command<{
-    action: {
-        type: "string";
-        description: string;
-        required: false;
-        default: string;
-    };
-    name: {
-        type: "positional";
-        description: string;
-        required: true;
-    };
-    global: {
-        type: "boolean";
-        alias: string;
-        description: string;
-    };
-    cwd: {
-        type: "string";
-        description: string;
-    };
-    workspace: {
-        type: "boolean";
-        description: string;
-    };
-    silent: {
-        type: "boolean";
-        description: string;
-    };
-    linter: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-    filter: {
-        type: "array";
-        description: string;
-    };
-    "from-catalog": {
-        type: "string";
-        description: string;
-    };
-    "catalog-name": {
-        type: "string";
-        description: string;
-    };
-    standalone: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-}>;
-export default _default;

package/bin/app/remove/cmd.js

@@ -1,303 +0,0 @@
-import { homedir, platform } from "node:os";
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { execa } from "execa";
-import { lookpath } from "lookpath";
-import { removeDependency } from "../utils/pm/pm-api.js";
-import { isCatalogSupported, removeFromCatalog } from "../utils/pm/pm-catalog.js";
-import { detectPackageManager } from "../utils/pm/pm-detect.js";
-export default defineCommand({
-  meta: {
-    name: "remove",
-    version: "1.1.0",
-    description: "Remove dependencies. Usage example: `dler remove package-name`"
-  },
-  args: defineArgs({
-    action: {
-      type: "string",
-      description: "Action to perform: remove, rm, uninstall, un, delete, del",
-      required: false,
-      default: "remove"
-    },
-    name: {
-      type: "positional",
-      description: "Package name",
-      required: true
-    },
-    global: {
-      type: "boolean",
-      alias: "g",
-      description: "Remove globally"
-    },
-    cwd: {
-      type: "string",
-      description: "Current working directory"
-    },
-    workspace: {
-      type: "boolean",
-      description: "Remove from workspace"
-    },
-    silent: {
-      type: "boolean",
-      description: "Run in silent mode"
-    },
-    linter: {
-      type: "boolean",
-      description: "Run linter checks after removing dependencies",
-      default: false
-    },
-    filter: {
-      type: "array",
-      description: "Filter workspaces to operate on (e.g., 'pkg-*', '!pkg-c', './packages/pkg-*')"
-    },
-    "from-catalog": {
-      type: "string",
-      description: "Remove dependencies from catalog (e.g., 'default', 'testing', 'build')"
-    },
-    "catalog-name": {
-      type: "string",
-      description: "Name of the catalog to remove dependencies from (used with --from-catalog)"
-    },
-    standalone: {
-      type: "boolean",
-      description: "Remove standalone dler installation",
-      default: false
-    }
-  }),
-  async run({ args }) {
-    const {
-      action,
-      name,
-      linter,
-      standalone,
-      filter,
-      "from-catalog": fromCatalog,
-      "catalog-name": catalogName,
-      ...options
-    } = args;
-    if (filter && filter.length > 0) {
-      const packageManager = await detectPackageManager(process.cwd());
-      if (packageManager) {
-        options.filter = filter;
-      }
-    }
-    if (fromCatalog && name) {
-      const packageManager = await detectPackageManager(process.cwd());
-      if (!packageManager) {
-        relinka("error", "Could not detect package manager");
-        return process.exit(1);
-      }
-      if (!isCatalogSupported(packageManager)) {
-        relinka(
-          "error",
-          `Catalogs are not supported by ${packageManager.name}. Only Bun supports catalogs.`
-        );
-        return process.exit(1);
-      }
-      const dependencies = Array.isArray(name) ? name : [name];
-      const catalogType = fromCatalog === "default" ? "catalog" : "catalogs";
-      const actualCatalogName = fromCatalog === "default" ? void 0 : catalogName || fromCatalog;
-      await removeFromCatalog(dependencies, catalogType, actualCatalogName, options.cwd);
-      return;
-    }
-    if (standalone) {
-      await removeStandaloneDler();
-      return;
-    }
-    if (!name) {
-      relinka.error("Package name is required for remove action");
-      return process.exit(1);
-    }
-    switch (action) {
-      case "remove":
-      case "rm":
-      case "uninstall":
-      case "un":
-      case "delete":
-      case "del":
-        await removeDependency(name, options);
-        break;
-      default: {
-        if (!action || action === "remove") {
-          await removeDependency(name, options);
-        } else {
-          relinka.error(`Unknown action: ${action}`);
-          relinka.verbose("Available actions: remove, rm, uninstall, un, delete, del");
-          return process.exit(1);
-        }
-      }
-    }
-  }
-});
-async function removeStandaloneDler() {
-  try {
-    relinka("info", "Removing standalone dler installation...");
-    const installDir = path.resolve(homedir(), ".reliverse", "dler");
-    const appsPath = path.resolve(homedir(), ".reliverse", "apps.json");
-    const currentMeta = await getCurrentAppsJson(appsPath, "dler");
-    if (!currentMeta) {
-      relinka("warn", "Standalone dler installation not found");
-      return;
-    }
-    const binaryInfo = getDlerBinaryInfo();
-    const binaryPath = path.resolve(installDir, binaryInfo.localName);
-    if (await fs.pathExists(binaryPath)) {
-      await fs.remove(binaryPath);
-      relinka("success", `Removed binary: ${binaryPath}`);
-    }
-    await removeFromPath(installDir);
-    await removeFromAppsJson(appsPath, "dler");
-    relinka("success", "Standalone dler installation removed successfully");
-    relinka("info", "Please restart your terminal for PATH changes to take effect");
-  } catch (error) {
-    relinka(
-      "error",
-      `Failed to remove standalone dler: ${error instanceof Error ? error.message : String(error)}`
-    );
-    process.exit(1);
-  }
-}
-function getDlerBinaryInfo() {
-  const os = platform();
-  if (os === "darwin") {
-    return {
-      filename: "dler-darwin-arm64",
-      localName: "dler"
-    };
-  } else if (os === "linux") {
-    return {
-      filename: "dler-linux",
-      localName: "dler"
-    };
-  } else if (os === "win32") {
-    return {
-      filename: "dler-windows.exe",
-      localName: "dler.exe"
-    };
-  } else {
-    throw new Error(`Unsupported platform: ${os}`);
-  }
-}
-async function getCurrentAppsJson(appsPath, binaryKey) {
-  try {
-    if (await fs.pathExists(appsPath)) {
-      const content = await fs.readFile(appsPath, "utf8");
-      const allMeta = JSON.parse(content);
-      return allMeta[binaryKey] || null;
-    }
-  } catch {
-  }
-  return null;
-}
-async function removeFromAppsJson(appsPath, binaryKey) {
-  try {
-    if (await fs.pathExists(appsPath)) {
-      const content = await fs.readFile(appsPath, "utf8");
-      const allMeta = JSON.parse(content);
-      delete allMeta[binaryKey];
-      if (Object.keys(allMeta).length === 0) {
-        await fs.remove(appsPath);
-        relinka("info", "Removed empty apps.json file");
-      } else {
-        await fs.writeFile(appsPath, JSON.stringify(allMeta, null, 2), "utf8");
-        relinka("info", "Updated apps.json file");
-      }
-    }
-  } catch (error) {
-    relinka("warn", `Could not update apps.json: ${error}`);
-  }
-}
-async function removeFromPath(installDir) {
-  const os = platform();
-  if (os === "win32") {
-    try {
-      await removeFromWindowsPath(installDir);
-      relinka("success", `Removed ${installDir} from PATH`);
-    } catch (error) {
-      relinka("warn", `Failed to automatically remove from PATH: ${error}`);
-      relinka("info", `Please manually remove ${installDir} from your PATH environment variable`);
-    }
-  } else {
-    const homeDir = homedir();
-    const shellRc = os === "darwin" ? path.resolve(homeDir, ".zshrc") : path.resolve(homeDir, ".bashrc");
-    try {
-      if (await fs.pathExists(shellRc)) {
-        let rcContent = await fs.readFile(shellRc, "utf8");
-        const pathExport = `export PATH="${installDir}:$PATH"`;
-        const commentLine = "# Added by dler get command";
-        rcContent = rcContent.replace(
-          new RegExp(
-            `
-${commentLine}
-${pathExport.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}
-`,
-            "g"
-          ),
-          "\n"
-        ).replace(
-          new RegExp(
-            `${commentLine}
-${pathExport.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}
-?`,
-            "g"
-          ),
-          ""
-        ).replace(new RegExp(`
-?${pathExport.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "g"), "");
-        await fs.writeFile(shellRc, rcContent, "utf8");
-        relinka("success", `Removed from PATH in ${shellRc}`);
-        relinka("info", "Please restart your terminal or run: source " + shellRc);
-      }
-    } catch (error) {
-      relinka("warn", `Could not modify shell RC file: ${error}`);
-      relinka("info", `Please manually remove ${installDir} from your PATH`);
-    }
-  }
-}
-async function removeFromWindowsPath(installDir) {
-  const psScript = `
-    function Refresh-Path {
-      $paths = @(
-        [System.Environment]::GetEnvironmentVariable("Path", "Machine"),
-        [System.Environment]::GetEnvironmentVariable("Path", "User"),
-        [System.Environment]::GetEnvironmentVariable("Path", "Process")
-      )
-      $uniquePaths = $paths |
-        Where-Object { $_ } |
-        ForEach-Object { $_.Split(';', [StringSplitOptions]::RemoveEmptyEntries) } |
-        Where-Object { $_ -and (Test-Path $_) } |
-        Select-Object -Unique
-      $env:Path = ($uniquePaths -join ';').TrimEnd(';')
-    }
-    function Remove-From-User-Path {
-      param([string]$Directory)
-      $absolutePath = Resolve-Path $Directory -ErrorAction SilentlyContinue
-      if (-not $absolutePath) {
-        $absolutePath = $Directory
-      }
-      $currentPath = [Environment]::GetEnvironmentVariable("Path", "User")
-      if (-not $currentPath) { 
-        Write-Host "No User PATH found"
-        return
-      }
-      # Split PATH and remove the target directory
-      $pathArray = $currentPath.Split(';', [StringSplitOptions]::RemoveEmptyEntries)
-      $filteredPaths = $pathArray | Where-Object { $_ -ne $absolutePath }
-      if ($pathArray.Count -eq $filteredPaths.Count) {
-        Write-Host "Directory not found in PATH"
-        return
-      }
-      $newPath = $filteredPaths -join ';'
-      Write-Host "Removing $absolutePath from User PATH..."
-      [Environment]::SetEnvironmentVariable("Path", $newPath, "User")
-      Refresh-Path
-      Write-Host "PATH updated successfully"
-    }
-    Remove-From-User-Path '${installDir.replace(/\\/g, "\\\\").replace(/'/g, "''")}' 
-  `.trim();
-  const pwshPath = await lookpath("pwsh");
-  const powershellCmd = pwshPath || "powershell";
-  await execa(powershellCmd, ["-Command", psScript]);
-}