@reliverse/dler 1.7.152 → 2.0.0

package/bin/impl/monorepo/commands-mod.js

@@ -1,159 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { execaCommand } from "execa";
-import { globby } from "globby";
-import {
-  cachePackageOutput,
-  cleanCache,
-  hashPackage,
-  isPackageCached,
-  restorePackageCache
-} from "./cache-mod.js";
-import { DependencyGraph } from "./graph-mod.js";
-import {
-  findMonorepo,
-  getCacheDir,
-  readPackageJson
-} from "./monorepo-mod.js";
-export async function buildCommand(ctx) {
-  if (process.env.INSIDE_DLER === "true") {
-    if (ctx.isDebug) {
-      relinka(
-        "log",
-        `[dler] \u2192 Ignoring dler, running command immediately: ${ctx.cmdArgs.join(" ")}`
-      );
-    }
-    if (ctx.cmdArgs.length === 0) {
-      relinka("error", "No command provided");
-      process.exit(1);
-    }
-    const command = ctx.cmdArgs.join(" ");
-    await execaCommand(command);
-    return;
-  }
-  const monorepo = await requireMonorepo(ctx);
-  const graph = await createGraph(monorepo);
-  const activePackage = requireActivePackage(ctx, graph);
-  const dependencies = graph.getPackageDependenciesBuildOrder(activePackage.name);
-  const packagesToBuild = [...dependencies, activePackage];
-  await buildCachedPackages(ctx, monorepo, packagesToBuild);
-}
-export async function depsCommand(ctx) {
-  if (process.env.INSIDE_DLER === "true") {
-    return;
-  }
-  const monorepo = await requireMonorepo(ctx);
-  const graph = await createGraph(monorepo);
-  const activePackage = requireActivePackage(ctx, graph);
-  const dependencies = graph.getPackageDependenciesBuildOrder(activePackage.name);
-  await buildCachedPackages(ctx, monorepo, dependencies);
-}
-export async function allCommand(ctx) {
-  const monorepo = await requireMonorepo(ctx);
-  const graph = await createGraph(monorepo);
-  const packages = graph.getOverallBuildOrder();
-  await buildCachedPackages(ctx, monorepo, packages);
-}
-export async function graphCommand(ctx) {
-  const monorepo = await requireMonorepo(ctx);
-  const graph = await createGraph(monorepo);
-  graph.print();
-}
-export async function cleanCommand(ctx) {
-  const monorepo = await findMonorepo();
-  if (monorepo) {
-    const cacheDir = getCacheDir(monorepo);
-    if (ctx.isDebug) {
-      relinka("log", `[dler] \u2192 Deleting cache at ${cacheDir}`);
-    }
-    await cleanCache(monorepo);
-  } else {
-    if (ctx.isDebug) {
-      relinka("log", "[dler] \u2192 Not in monorepo");
-    }
-  }
-  relinka("log", "\u2713 Cache deleted");
-}
-async function requireMonorepo(ctx) {
-  const monorepo = await findMonorepo();
-  if (!monorepo) {
-    relinka("error", "Monorepo root not found. Are you inside a monorepo?");
-    process.exit(1);
-  }
-  if (ctx.isDebug) {
-    relinka("log", `[dler] \u2192 Monorepo found at ${monorepo.root}`);
-  }
-  return monorepo;
-}
-async function createGraph(monorepo) {
-  const packageJsonGlobs = monorepo.packageGlobs.map((glob) => `${glob}/package.json`);
-  const matches = await globby(packageJsonGlobs, { cwd: monorepo.root, absolute: true });
-  const packages = [];
-  for (const packageJsonPath of matches) {
-    const pkg = await readPackageJson(packageJsonPath);
-    if (pkg) {
-      packages.push(pkg);
-    }
-  }
-  return new DependencyGraph(packages);
-}
-function requireActivePackage(ctx, graph) {
-  const activePackage = graph.findActivePackage();
-  if (!activePackage) {
-    relinka("error", "Not inside a package directory, could not determine dependencies to build");
-    process.exit(1);
-  }
-  if (ctx.isDebug) {
-    relinka("log", `[dler] \u2192 Active package ${activePackage.dir}`);
-  }
-  return activePackage;
-}
-async function buildCachedPackages(ctx, monorepo, packages) {
-  if (ctx.isDebug) {
-    const packageNames = packages.map((p) => p.name);
-    relinka("log", `[dler] \u2192 Packages to build: ${packageNames.join(", ")}`);
-  }
-  for (const pkg of packages) {
-    await buildCachedPackage(ctx, monorepo, pkg);
-  }
-}
-async function buildCachedPackage(ctx, monorepo, pkg) {
-  if (!pkg.buildScript) {
-    relinka("log", `\u2713 ${pkg.name}: Nothing to build`);
-    return;
-  }
-  const args = [...monorepo.packageManager.runCmd, "build"];
-  if (ctx.isDebug) {
-    const relativeDir = pkg.dir.replace(monorepo.root, "").replace(/^\//, "");
-    relinka("log", `[dler] \u2192 Running ${args.join(" ")} in ${relativeDir}`);
-  }
-  relinka("log", `\u25D0 ${pkg.name}: ${pkg.buildScript}`);
-  const { packageHash } = await hashPackage(pkg);
-  const cacheDir = getPackageCacheDir(monorepo, pkg, packageHash);
-  if (ctx.isDebug) {
-    relinka("log", `[dler] \u2192 Cache dir: ${cacheDir}`);
-  }
-  if (await isPackageCached(monorepo, pkg, packageHash) && pkg.config.cache) {
-    await restorePackageCache(monorepo, pkg, packageHash);
-    relinka("log", `\u2713 ${pkg.name}: Cached!`);
-    return;
-  }
-  await execInDir(pkg.dir, args);
-  if (pkg.config.cache) {
-    await cachePackageOutput(monorepo, pkg, packageHash);
-  }
-  relinka("log", `\u2713 ${pkg.name}: Built`);
-}
-async function execInDir(dir, args) {
-  if (args.length === 0) {
-    relinka("error", "No command provided");
-    process.exit(1);
-  }
-  const command = args.join(" ");
-  await execaCommand(command, {
-    cwd: dir,
-    env: { ...process.env, INSIDE_DLER: "true" }
-  });
-}
-function getPackageCacheDir(monorepo, pkg, packageHash) {
-  return `${monorepo.root}/.cache/${pkg.name}/${packageHash}`;
-}

package/bin/impl/monorepo/graph-mod.d.ts

@@ -1,29 +0,0 @@
-import type { Package } from "./monorepo-mod";
-export interface GraphNode {
-    id: string;
-    package: Package;
-    children: GraphNode[];
-}
-export declare class DependencyGraph {
-    private readonly root;
-    private readonly nodeMap;
-    constructor(packages: Package[]);
-    /**
-     * Get all packages in build order (dependencies first)
-     */
-    getOverallBuildOrder(): Package[];
-    /**
-     * Get dependencies for a specific package in build order
-     */
-    getPackageDependenciesBuildOrder(packageName: string): Package[];
-    /**
-     * Find the package that contains the current working directory
-     */
-    findActivePackage(): Package | null;
-    /**
-     * Print the dependency graph as a tree
-     */
-    print(): void;
-    private depthFirstSearch;
-    private printNode;
-}

package/bin/impl/monorepo/graph-mod.js

@@ -1,106 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-export class DependencyGraph {
-  root;
-  nodeMap = /* @__PURE__ */ new Map();
-  constructor(packages) {
-    this.root = {
-      id: "root",
-      package: {
-        dir: "",
-        name: "root",
-        dependencyNames: [],
-        config: { cache: false, outDir: "dist", include: [], exclude: [] }
-      },
-      children: []
-    };
-    const nodes = packages.map((pkg) => ({
-      id: pkg.name,
-      package: pkg,
-      children: []
-    }));
-    this.root.children = [...nodes];
-    for (const node of nodes) {
-      this.nodeMap.set(node.id, node);
-    }
-    for (const pkg of packages) {
-      const packageNode = this.nodeMap.get(pkg.name);
-      if (!packageNode) continue;
-      for (const depName of pkg.dependencyNames) {
-        const depNode = this.nodeMap.get(depName);
-        if (depNode) {
-          packageNode.children.push(depNode);
-        }
-      }
-    }
-  }
-  /**
-   * Get all packages in build order (dependencies first)
-   */
-  getOverallBuildOrder() {
-    const visited = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const child of this.root.children) {
-      this.depthFirstSearch(child, visited, result);
-    }
-    return result;
-  }
-  /**
-   * Get dependencies for a specific package in build order
-   */
-  getPackageDependenciesBuildOrder(packageName) {
-    const node = this.nodeMap.get(packageName);
-    if (!node) return [];
-    const visited = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const child of node.children) {
-      this.depthFirstSearch(child, visited, result);
-    }
-    return result;
-  }
-  /**
-   * Find the package that contains the current working directory
-   */
-  findActivePackage() {
-    const currentDir = process.cwd();
-    for (const node of this.root.children) {
-      if (currentDir.startsWith(node.package.dir)) {
-        return node.package;
-      }
-    }
-    return null;
-  }
-  /**
-   * Print the dependency graph as a tree
-   */
-  print() {
-    relinka("log", "Dependency Graph:");
-    this.printNode(this.root, 0, true);
-  }
-  depthFirstSearch(node, visited, result) {
-    if (visited.has(node.id)) return;
-    visited.add(node.id);
-    for (const child of node.children) {
-      this.depthFirstSearch(child, visited, result);
-    }
-    if (node.id !== "root") {
-      result.push(node.package);
-    }
-  }
-  printNode(node, depth, isLast) {
-    const indent = "\u2502 ".repeat(depth);
-    const connector = isLast ? "\u2514" : "\u251C";
-    const name = node.id === "root" ? "" : node.id;
-    if (name) {
-      relinka("log", `${indent}${connector} ${name}`);
-    }
-    if (node.children.length > 0) {
-      const lastIndex = node.children.length - 1;
-      for (let i = 0; i < node.children.length; i++) {
-        const child = node.children[i];
-        if (child) {
-          this.printNode(child, depth + 1, i === lastIndex);
-        }
-      }
-    }
-  }
-}

package/bin/impl/monorepo/mod.d.ts

@@ -1,5 +0,0 @@
-export * from "./cache-mod";
-export * from "./commands-mod";
-export * from "./graph-mod";
-export * from "./monorepo-mod";
-export { readPackageJson as readMonorepoPackageJson } from "./monorepo-mod";

package/bin/impl/monorepo/mod.js

@@ -1,5 +0,0 @@
-export * from "./cache-mod.js";
-export * from "./commands-mod.js";
-export * from "./graph-mod.js";
-export * from "./monorepo-mod.js";
-export { readPackageJson as readMonorepoPackageJson } from "./monorepo-mod.js";

package/bin/impl/monorepo/monorepo-mod.d.ts

@@ -1,26 +0,0 @@
-export interface PackageManager {
-    name: "pnpm" | "bun" | "npm" | "yarn";
-    runCmd: string[];
-}
-export interface Package {
-    dir: string;
-    name: string;
-    buildScript?: string;
-    dependencyNames: string[];
-    config: PackageConfig;
-}
-export interface PackageConfig {
-    cache: boolean;
-    outDir: string;
-    include: string[];
-    exclude: string[];
-}
-export interface Monorepo {
-    root: string;
-    packageManager: PackageManager;
-    packageGlobs: string[];
-}
-export declare function createPackageConfig(json: any): PackageConfig;
-export declare function findMonorepo(): Promise<Monorepo | null>;
-export declare function readPackageJson(packageJsonPath: string): Promise<Package | null>;
-export declare function getCacheDir(monorepo: Monorepo): string;

package/bin/impl/monorepo/monorepo-mod.js

@@ -1,152 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { detectPackageManager } from "../utils/pm/pm-detect.js";
-const DEFAULT_CACHED = true;
-const DEFAULT_OUT_DIR = "dist";
-const DEFAULT_INCLUDE = ["src/**/*"];
-const DEFAULT_EXCLUDE = [
-  "**/__tests__/**",
-  "**/__mocks__/**",
-  "**/*.test.*",
-  "**/e2e/**",
-  "**/dist/**",
-  "**/.output/**"
-];
-export function createPackageConfig(json) {
-  const dler = json.dler || {};
-  return {
-    cache: dler.cache ?? DEFAULT_CACHED,
-    outDir: dler.outDir ?? DEFAULT_OUT_DIR,
-    include: dler.include ?? DEFAULT_INCLUDE,
-    exclude: dler.exclude ?? DEFAULT_EXCLUDE
-  };
-}
-export async function findMonorepo() {
-  let currentDir = process.cwd();
-  while (true) {
-    const workspace = await readWorkspace(currentDir);
-    if (workspace) {
-      return {
-        root: currentDir,
-        packageManager: workspace.packageManager,
-        packageGlobs: workspace.packageGlobs
-      };
-    }
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) {
-      break;
-    }
-    currentDir = parentDir;
-  }
-  return null;
-}
-async function readWorkspace(path2) {
-  const pnpmWorkspacePath = path2 + "/pnpm-workspace.yaml";
-  if (await fs.pathExists(pnpmWorkspacePath)) {
-    try {
-      const content = await fs.readFile(pnpmWorkspacePath, "utf-8");
-      const yaml = JSON.parse(content);
-      const packages = yaml.packages || [];
-      return {
-        packageManager: {
-          name: "pnpm",
-          runCmd: ["pnpm", "--silent", "run"]
-        },
-        packageGlobs: packages
-      };
-    } catch (error) {
-      relinka("warn", `Failed to parse pnpm-workspace.yaml: ${error}`);
-    }
-  }
-  const packageJsonPath = path2 + "/package.json";
-  if (await fs.pathExists(packageJsonPath)) {
-    try {
-      const content = await fs.readFile(packageJsonPath, "utf-8");
-      const json = JSON.parse(content);
-      if (json.workspaces) {
-        const detectedPM = await detectPackageManager(path2, {
-          ignorePackageJSON: true
-          // We already have the package.json
-        });
-        let packageManager;
-        if (detectedPM) {
-          switch (detectedPM.name) {
-            case "bun":
-              packageManager = {
-                name: "bun",
-                runCmd: ["bun", "--silent", "run"]
-              };
-              break;
-            case "yarn":
-              packageManager = {
-                name: "yarn",
-                runCmd: ["yarn", "run"]
-              };
-              break;
-            case "npm":
-              packageManager = {
-                name: "npm",
-                runCmd: ["npm", "run"]
-              };
-              break;
-            case "pnpm":
-              packageManager = {
-                name: "pnpm",
-                runCmd: ["pnpm", "--silent", "run"]
-              };
-              break;
-            default:
-              packageManager = {
-                name: "bun",
-                runCmd: ["bun", "--silent", "run"]
-              };
-          }
-        } else {
-          packageManager = {
-            name: "bun",
-            runCmd: ["bun", "--silent", "run"]
-          };
-        }
-        return {
-          packageManager,
-          packageGlobs: Array.isArray(json.workspaces) ? json.workspaces : []
-        };
-      }
-    } catch (error) {
-      relinka("warn", `Failed to parse package.json: ${error}`);
-    }
-  }
-  return null;
-}
-export async function readPackageJson(packageJsonPath) {
-  try {
-    const content = await fs.readFile(packageJsonPath, "utf-8");
-    const json = JSON.parse(content);
-    const name = json.name;
-    if (!name) {
-      return null;
-    }
-    const buildScript = json.scripts?.build;
-    const dependencyNames = [];
-    const deps = { ...json.dependencies, ...json.devDependencies };
-    for (const [depName, version] of Object.entries(deps)) {
-      if (typeof version === "string" && version.startsWith("workspace:")) {
-        dependencyNames.push(depName);
-      }
-    }
-    return {
-      dir: path.dirname(packageJsonPath),
-      name,
-      buildScript,
-      dependencyNames,
-      config: createPackageConfig(json)
-    };
-  } catch (error) {
-    relinka("warn", `Failed to read package.json at ${packageJsonPath}: ${error}`);
-    return null;
-  }
-}
-export function getCacheDir(monorepo) {
-  return path.join(monorepo.root, ".cache");
-}

package/bin/impl/mrse/mrse-impl.d.ts

@@ -1,53 +0,0 @@
-/**
- * Determines if we log additional debug info.
- * Set to `true` for verbose output.
- */
-export declare const mrseVerbose = false;
-/**
- * Helper to conditionally log verbose messages based on `mrseVerbose`.
- * @param msg - The message to log.
- * @param data - Optional additional data to log.
- */
-export declare function logVerbose(msg: string, data?: unknown): void;
-/**
- * Configuration data for a single project.
- */
-export interface GenCfg {
-    projectName: string;
-    projectTemplate: string;
-    getEnvExample: boolean;
-    projectPath?: string;
-}
-/**
- * Shape of the JSONC config file (wrapper around GenCfg[]).
- */
-export interface GenCfgJsonc {
-    genCfg: GenCfg[];
-}
-/**
- * Gets the path to the env cache directory (used for storing .env.example files).
- * @returns Absolute path to the `.reliverse/envs` directory.
- */
-export declare function getEnvCacheDir(): string;
-/**
- * Ensures the env cache directory exists (creates if necessary).
- * @returns The cache directory path.
- */
-export declare function ensureEnvCacheDir(): Promise<string>;
-/**
- * Builds the full cache file path for a repository's `.env.example` file.
- * @param repo - Owner/repo string.
- * @param branch - The git branch (defaults to "main").
- * @returns The absolute path to the cached `.env.example` file.
- */
-export declare function getEnvCachePath(repo: string, branch?: string): string;
-/**
- * Downloads a `.env.example` file from a GitHub repository with optional caching.
- * @param repo - The owner/repo string (e.g., "username/repo").
- * @param filePath - The file path within the repo (usually ".env.example").
- * @param branch - The git branch to use. Defaults to "main".
- * @param useCache - Whether to use local caching. Defaults to true.
- * @param useFresh - If true, bypasses existing cache. Defaults to false.
- * @returns The file content as a string, or null if download fails.
- */
-export declare function downloadFileFromGitHub(repo: string, filePath: string, branch?: string, useCache?: boolean, useFresh?: boolean): Promise<string | null>;

package/bin/impl/mrse/mrse-impl.js

@@ -1,132 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs, { ensuredir } from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt } from "@reliverse/rempts";
-import { homeDir } from "../config/constants.js";
-import { getOrCreateReliverseConfig } from "../config/core.js";
-import { initGithubSDK } from "../utils/instanceGithub.js";
-import { askUsernameFrontend } from "../utils/prompts/askUsernameFrontend.js";
-import { getOrCreateReliverseMemory } from "../utils/reliverseMemory.js";
-export const mrseVerbose = false;
-export function logVerbose(msg, data) {
-  if (mrseVerbose) {
-    console.log(`Debug - ${msg}`, data ?? "");
-  }
-}
-export function getEnvCacheDir() {
-  return path.join(homeDir, ".reliverse", "envs");
-}
-export async function ensureEnvCacheDir() {
-  const cacheDir = getEnvCacheDir();
-  await ensuredir(cacheDir);
-  return cacheDir;
-}
-export function getEnvCachePath(repo, branch = "main") {
-  const cacheDir = getEnvCacheDir();
-  const safeRepoName = repo.replace(/[/\\:]/g, "_");
-  return path.join(cacheDir, `${safeRepoName}_${branch}.env.example`);
-}
-export async function downloadFileFromGitHub(repo, filePath, branch = "main", useCache = true, useFresh = false) {
-  if (useCache && !useFresh) {
-    const cachePath = getEnvCachePath(repo, branch);
-    const cacheExists = await fs.pathExists(cachePath);
-    if (cacheExists) {
-      const stats = await fs.stat(cachePath);
-      const fileAge = Date.now() - stats.mtimeMs;
-      const oneDayMs = 24 * 60 * 60 * 1e3;
-      if (fileAge < oneDayMs) {
-        logVerbose(`Using cached .env.example for ${repo} (${branch}).`);
-        return fs.readFile(cachePath, "utf-8");
-      }
-    }
-  }
-  let repoOwner = "";
-  let repoName = "";
-  try {
-    if (repo.includes("/")) {
-      const repoParts = repo.split("/");
-      if (repoParts.length !== 2) {
-        throw new Error(`Invalid repository format: "${repo}". Expected format: "owner/repo".`);
-      }
-      repoOwner = repoParts[0];
-      repoName = repoParts[1];
-    }
-    const maskInput = await confirmPrompt({
-      title: "Do you want to mask secret inputs (e.g., GitHub token) in the next steps?",
-      content: "Regardless of your choice, your data will be securely stored on your device."
-    });
-    const memory = await getOrCreateReliverseMemory();
-    const { config } = await getOrCreateReliverseConfig({
-      projectPath: process.cwd(),
-      isDev: false,
-      overrides: {}
-    });
-    const frontendUsername = await askUsernameFrontend(config, false);
-    if (!frontendUsername) {
-      throw new Error(
-        "Failed to determine your frontend username. Please try again or notify the CLI developers."
-      );
-    }
-    const githubResult = await initGithubSDK(memory, frontendUsername, maskInput);
-    if (!githubResult) {
-      throw new Error(
-        "Failed to initialize Octokit SDK. Please notify CLI developers if the problem persists."
-      );
-    }
-    const [githubToken, githubInstance, githubUsername] = githubResult;
-    if (repoOwner !== githubUsername && repoOwner !== "") {
-      throw new Error(
-        `Private repository ${repo} owned by a different user (${repoOwner}) cannot be accessed. 
-Please use a repository you own or a public repository.`
-      );
-    }
-    if (!repoOwner || !repoName) {
-      throw new Error(`Invalid repository format: "${repo}". Expected format: "owner/repo".`);
-    }
-    logVerbose(
-      `${useFresh ? "Fresh mode - d" : "D"}ownloading file from GitHub: ${repoOwner}/${repoName}/${filePath} (branch: ${branch}).`
-    );
-    const response = await githubInstance.rest.repos.getContent({
-      owner: repoOwner,
-      repo: repoName,
-      path: filePath,
-      ref: `refs/heads/${branch}`,
-      headers: {
-        authorization: `Bearer ${githubToken}`
-      }
-    });
-    if (response.status !== 200) {
-      relinka(
-        "warn",
-        `Failed to download ${filePath} from ${repo} (${branch}): ${response.status}`
-      );
-      return null;
-    }
-    const data = response.data;
-    if (Array.isArray(data) || data.type !== "file" || !data.content || !data.encoding) {
-      relinka("warn", `Unexpected response format for ${filePath} from ${repo} (${branch}).`);
-      return null;
-    }
-    if (data.encoding !== "base64") {
-      relinka(
-        "warn",
-        `Unexpected encoding for ${filePath} from ${repo} (${branch}): ${data.encoding}.`
-      );
-      return null;
-    }
-    const decodedContent = Buffer.from(data.content, "base64").toString("utf-8");
-    if (useCache) {
-      const cachePath = getEnvCachePath(repo, branch);
-      await ensureEnvCacheDir();
-      await fs.writeFile(cachePath, decodedContent);
-      logVerbose(`Cached .env.example for ${repo} (${branch}) at ${cachePath}.`);
-    }
-    return decodedContent;
-  } catch (error) {
-    relinka(
-      "warn",
-      `Failed to download ${filePath} from ${repo} (${branch}): ${error instanceof Error ? error.message : String(error)}`
-    );
-    return null;
-  }
-}