@reliverse/dler 1.7.153 → 2.0.1

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;
-  }
-}

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

@@ -1,43 +0,0 @@
-export interface FileMetadata {
-    updatedAt?: string;
-    updatedHash?: string;
-}
-export interface TemplatesFileContent {
-    content: FileContent;
-    type: "text" | "json" | "binary";
-    hasError?: boolean;
-    error?: string;
-    jsonComments?: Record<number, string>;
-    binaryHash?: string;
-    metadata?: FileMetadata;
-}
-export type FileContent = string | Record<string, unknown>;
-export interface Template {
-    name: string;
-    description: string;
-    config: {
-        files: Record<string, TemplatesFileContent>;
-    };
-    updatedAt?: string;
-}
-export type ExistingTemplates = Record<string, Template>;
-export declare const WHITELABEL_DEFAULT = "DLER";
-export declare const TEMPLATE_VAR: (name: string, whitelabel: string) => string;
-export declare const TPLS_DIR = "packed";
-export declare const BINARIES_DIR = "binaries";
-/** Escape back-`s, ${ and newlines for safe template literal embedding */
-export declare const escapeTemplateString: (str: string) => string;
-export declare const unescapeTemplateString: (str: string) => string;
-export declare const hashFile: (file: string) => Promise<string>;
-export declare const getFileMetadata: (file: string) => Promise<FileMetadata>;
-/** Recursively walk a directory */
-export declare const walkDir: (dir: string) => Promise<string[]>;
-/** Process a file and return the TemplatesFileContent structure */
-export declare const readFileForTemplate: (absPath: string, relPath: string, binariesOutDir: string) => Promise<TemplatesFileContent>;
-/** Locate the object holding templates in a dynamically-imported module */
-export declare const findTemplatesObject: (mod: Record<string, unknown>) => ExistingTemplates;
-/** Restore one file (text|json|binary) to the filesystem */
-export declare const restoreFile: (outRoot: string, relPath: string, meta: TemplatesFileContent, binsDir: string, force?: boolean) => Promise<void>;
-/** Unpack logic */
-export declare const unpackTemplates: (aggregatorPath: string, outDir: string, force?: boolean) => Promise<void>;
-export declare const writeTypesFile: (outRoot: string, outputName: string) => Promise<void>;