@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/cmds/transform/transform-impl-mod.js

@@ -0,0 +1,178 @@
+import { promises as fs } from "node:fs";
+import MagicString, { Bundle } from "magic-string";
+export const createTransformerFromMagicString = (ms, original) => {
+  const transformer = {
+    original,
+    _ms: ms,
+    current: () => ms.toString(),
+    hasChanged: () => ms.hasChanged(),
+    isEmpty: () => ms.isEmpty(),
+    clone: () => createTransformerFromMagicString(ms.clone(), original),
+    generateMap: (mapOptions) => ms.generateMap(mapOptions),
+    generateDecodedMap: (mapOptions) => ms.generateDecodedMap(mapOptions)
+  };
+  return transformer;
+};
+export const createTransformer = (source, options) => {
+  const ms = new MagicString(source, options);
+  return createTransformerFromMagicString(ms, source);
+};
+export const update = (transformer, start, end, content, options) => {
+  const ms = transformer._ms.clone();
+  ms.update(start, end, content, options);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const overwrite = (transformer, start, end, content, options) => {
+  const ms = transformer._ms.clone();
+  ms.overwrite(start, end, content, options);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const append = (transformer, content) => {
+  const ms = transformer._ms.clone();
+  ms.append(content);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const prepend = (transformer, content) => {
+  const ms = transformer._ms.clone();
+  ms.prepend(content);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const remove = (transformer, start, end) => {
+  const ms = transformer._ms.clone();
+  ms.remove(start, end);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const replace = (transformer, searchValue, replaceValue) => {
+  const ms = transformer._ms.clone();
+  ms.replace(searchValue, replaceValue);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const replaceAll = (transformer, searchValue, replaceValue) => {
+  const ms = transformer._ms.clone();
+  ms.replaceAll(searchValue, replaceValue);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const indent = (transformer, prefix, options) => {
+  const ms = transformer._ms.clone();
+  ms.indent(prefix, options);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const trim = (transformer, charType) => {
+  const ms = transformer._ms.clone();
+  ms.trim(charType);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const pipe = (value, ...operations) => {
+  return operations.reduce((acc, operation) => operation(acc), value);
+};
+export const wrapWith = (transformer, prefix, suffix) => {
+  return pipe(
+    transformer,
+    (t) => prepend(t, prefix),
+    (t) => append(t, suffix)
+  );
+};
+export const insertAt = (transformer, index, content) => {
+  const ms = transformer._ms.clone();
+  ms.appendLeft(index, content);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const slice = (transformer, start = 0, end) => {
+  const currentString = transformer.current();
+  return currentString.slice(start, end ?? currentString.length);
+};
+export const template = (strings, ...values) => {
+  const source = strings.reduce((result, string, i) => result + string + (values[i] || ""), "");
+  return createTransformer(source);
+};
+export const readAndTransform = async (filePath, transformer) => {
+  const content = await fs.readFile(filePath, "utf-8");
+  const original = createTransformer(content);
+  const transformed = transformer(original);
+  return {
+    code: transformed.current(),
+    hasChanged: transformed.hasChanged(),
+    transformer: transformed
+  };
+};
+export const transformAndWrite = async (inputPath, outputPath, transformer, options) => {
+  const result = await readAndTransform(inputPath, transformer);
+  await fs.writeFile(outputPath, result.code);
+  if (options?.generateSourceMap && options.sourceMapPath) {
+    const map = result.transformer.generateMap({
+      source: inputPath,
+      file: options.sourceMapPath,
+      includeContent: true
+    });
+    await fs.writeFile(options.sourceMapPath, map.toString());
+  }
+};
+export const transformMultiple = async (transformations) => {
+  await Promise.all(
+    transformations.map(
+      ({ input, output, transformer }) => transformAndWrite(input, output, transformer)
+    )
+  );
+};
+export const createBundle = (sources = []) => {
+  const bundle = new Bundle();
+  for (const source of sources) {
+    bundle.addSource({
+      filename: source.filename,
+      content: new MagicString(source.content.current()),
+      ignoreList: source.ignoreList,
+      indentExclusionRanges: source.indentExclusionRanges
+    });
+  }
+  return {
+    addSource: (source) => {
+      bundle.addSource({
+        filename: source.filename,
+        content: new MagicString(source.content.current()),
+        ignoreList: source.ignoreList,
+        indentExclusionRanges: source.indentExclusionRanges
+      });
+      return createBundle([]);
+    },
+    indent: (prefix) => {
+      bundle.indent(prefix);
+      return createBundle([]);
+    },
+    prepend: (content) => {
+      bundle.prepend(content);
+      return createBundle([]);
+    },
+    append: (content) => {
+      bundle.append(content);
+      return createBundle([]);
+    },
+    toString: () => bundle.toString(),
+    generateMap: (options) => bundle.generateMap(options)
+  };
+};
+export const compose = (...transformers) => {
+  return (input) => transformers.reduceRight((acc, transformer) => transformer(acc), input);
+};
+export * from "magic-string";
+export default {
+  createTransformer,
+  update,
+  overwrite,
+  append,
+  prepend,
+  remove,
+  replace,
+  replaceAll,
+  indent,
+  trim,
+  pipe,
+  wrapWith,
+  insertAt,
+  slice,
+  template,
+  readAndTransform,
+  transformAndWrite,
+  transformMultiple,
+  createBundle,
+  compose
+};

package/bin/app/cmds.d.ts

@@ -1,4 +1,7 @@
 import type { Command } from "@reliverse/rempts";
+export declare const getWebCmd: () => Promise<Command<import("@reliverse/rempts").EmptyArgs>>;
+export declare const getAuthCmd: () => Promise<Command<import("@reliverse/rempts").EmptyArgs>>;
+export declare const getAuthGenerateCmd: () => Promise<Command<import("@reliverse/rempts").EmptyArgs>>;
 interface CommandArgsMap {
     agg: {
         imports?: boolean;

package/bin/app/cmds.js

@@ -1,4 +1,7 @@
-import { loadCommand, callCmdImpl, getTypedCmdImpl } from "@reliverse/rempts";
+import { callCmdImpl, getTypedCmdImpl, loadCommand } from "@reliverse/rempts";
+export const getWebCmd = async () => await loadCommand("./web/cmd");
+export const getAuthCmd = async () => await loadCommand("./auth/cmd");
+export const getAuthGenerateCmd = async () => await loadCommand("./auth/generate/cmd");
 export async function loadTypedCommand(cmdName) {
   return await loadCommand(cmdName);
 }

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

@@ -0,0 +1,31 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    codemods: {
+        type: "positional";
+        required: false;
+        array: boolean;
+        description: string;
+    };
+    dry: {
+        type: "boolean";
+        description: string;
+        default: false;
+        required: false;
+    };
+    format: {
+        type: "boolean";
+        description: string;
+        default: false;
+        required: false;
+    };
+    include: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+    exclude: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+}>;
+export default _default;

package/bin/app/cmod/cmd.js

@@ -0,0 +1,66 @@
+import { re } from "@reliverse/relico";
+import { defineCommand } from "@reliverse/rempts";
+import { prompt } from "enquirer";
+import { runCodemods } from "./cmod-impl.js";
+const sampleCodemods = [
+  "use-react-router-v6",
+  "migrate-to-nextjs-14",
+  "class-to-functional",
+  "js-to-ts",
+  "react/19/migration-recipe"
+];
+export default defineCommand({
+  meta: {
+    name: "cmod",
+    description: "Run codemods via the codemod CLI"
+  },
+  args: {
+    // List of codemod names, if user wants to directly apply them
+    codemods: {
+      type: "positional",
+      required: false,
+      array: true,
+      description: "Names of codemods to run (e.g. react/19/migration-recipe)"
+    },
+    dry: {
+      type: "boolean",
+      description: "Perform a dry run without applying changes",
+      default: false,
+      required: false
+    },
+    format: {
+      type: "boolean",
+      description: "Enable biome formatting after codemod runs",
+      default: false,
+      required: false
+    },
+    include: {
+      type: "string",
+      description: "Glob pattern for files to include",
+      required: false
+    },
+    exclude: {
+      type: "string",
+      description: "Glob pattern for files to exclude",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const { codemods, dry, format, include, exclude } = args;
+    if (codemods && codemods.length > 0) {
+      return await runCodemods([codemods], { dry, format, include, exclude });
+    }
+    console.log(re.green("\n\u25C6 Rse Codemod Selection\n"));
+    const { chosen } = await prompt({
+      type: "multiselect",
+      name: "chosen",
+      message: "Select one or more codemods to run:",
+      choices: sampleCodemods.map((cm) => ({ name: cm }))
+    });
+    if (!chosen || chosen.length === 0) {
+      console.log(re.yellow("No codemods selected. Exiting..."));
+      return;
+    }
+    await runCodemods(chosen, { dry, format, include, exclude });
+  }
+});

package/bin/app/cmod/cmod-impl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Runs each codemod one by one using `codemod <name> <optional-flags>`.
+ */
+export declare function runCodemods(names: string[], options: {
+    dry?: boolean;
+    format?: boolean;
+    include?: string;
+    exclude?: string;
+}): Promise<void>;

package/bin/app/cmod/cmod-impl.js

@@ -0,0 +1,21 @@
+import { relinka } from "@reliverse/relinka";
+import { execaCommand } from "execa";
+export async function runCodemods(names, options) {
+  for (const name of names) {
+    relinka("info", `
+Applying codemod: ${name}`);
+    const cmdArgs = [name];
+    if (options.dry) cmdArgs.push("--dry");
+    if (options.format) cmdArgs.push("--format");
+    if (options.include) cmdArgs.push("-i", options.include);
+    if (options.exclude) cmdArgs.push("-e", options.exclude);
+    try {
+      await execaCommand(`codemod ${cmdArgs}`, { stdio: "inherit" });
+      relinka("info", `Successfully ran codemod: ${name}
+`);
+    } catch (error) {
+      relinka("error", `Failed to run codemod: ${name}`, String(error));
+      process.exit(1);
+    }
+  }
+}

package/bin/app/config/cfg-biome.d.ts

@@ -0,0 +1,2 @@
+import type { BiomeConfigResult } from "../types/mod.js";
+export declare function getBiomeConfig(projectPath: string): Promise<BiomeConfigResult>;

package/bin/app/config/cfg-biome.js

@@ -0,0 +1,34 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { parseJSONC } from "confbox";
+let cachedBiomeConfig = null;
+export async function getBiomeConfig(projectPath) {
+  if (cachedBiomeConfig !== null) {
+    return cachedBiomeConfig;
+  }
+  try {
+    const biomePath = path.join(projectPath, "biome.jsonc");
+    if (await fs.pathExists(biomePath)) {
+      const content = await fs.readFile(biomePath, "utf-8");
+      const config = parseJSONC(content);
+      cachedBiomeConfig = {
+        lineWidth: config.formatter?.lineWidth ?? 80,
+        indentStyle: config.formatter?.indentStyle ?? "space",
+        indentWidth: config.formatter?.indentWidth ?? 2,
+        quoteMark: config.javascript?.formatter?.quoteStyle ?? "double",
+        semicolons: config.javascript?.formatter?.semicolons === "always",
+        trailingComma: config.javascript?.formatter?.trailingComma === "all"
+      };
+      return cachedBiomeConfig;
+    }
+  } catch (error) {
+    relinka(
+      "verbose",
+      "Error reading biome config:",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  cachedBiomeConfig = null;
+  return null;
+}

package/bin/app/config/cfg-comments.d.ts

@@ -0,0 +1 @@
+export declare function injectSectionComments(fileContent: string): string;

package/bin/app/config/cfg-comments.js

@@ -0,0 +1,57 @@
+import MagicString from "magic-string";
+import { cliDomainDocs } from "./constants.js";
+export function injectSectionComments(fileContent) {
+  const ms = new MagicString(fileContent);
+  const comment = (text) => text ? `// ${text}` : "";
+  const commentSections = {
+    $schema: [
+      comment(`RSE CONFIG (${cliDomainDocs})`),
+      comment("Restart the CLI to apply your config changes")
+    ],
+    projectName: [comment("General project information")],
+    skipPromptsUseAutoBehavior: [
+      comment("Enable auto-answering for prompts to skip manual confirmations."),
+      comment("Make sure you have unknown values configured above.")
+    ],
+    features: [comment("Project features")],
+    projectFramework: [comment("Primary tech stack/framework")],
+    codeStyle: [comment("Code style preferences")],
+    multipleRepoCloneMode: [comment("Settings for cloning an existing repo")],
+    envComposerOpenBrowser: [
+      comment("Set to false to disable opening the browser during env composing")
+    ],
+    ignoreDependencies: [comment("List dependencies to exclude from checks")],
+    customRules: [
+      comment("Provide custom rules for Reliverse AI"),
+      comment("You can use any json type here in {}")
+    ],
+    deployBehavior: [
+      comment("Prompt behavior for deployment"),
+      comment("Options: prompt | autoYes | autoNo")
+    ],
+    existingRepoBehavior: [
+      comment("Behavior for existing GitHub repos during project creation"),
+      comment("Options: prompt | autoYes | autoYesSkipCommit | autoNo")
+    ],
+    relinterConfirm: [
+      comment("Behavior for Reliverse AI chat and agent mode"),
+      comment("Options: promptOnce | promptEachFile | autoYes")
+    ]
+  };
+  for (const [section, lines] of Object.entries(commentSections)) {
+    if (!lines?.length) continue;
+    const combinedComments = lines.map((line, idx) => idx === 0 ? line : `  ${line}`).join("\n");
+    const regex = new RegExp(`(\\s+)(["']?)${section.replace("$", "\\$")}(\\2):`, "g");
+    let match = regex.exec(fileContent);
+    while (match !== null) {
+      const insertPos = match.index;
+      const insertion = `
+  ${combinedComments}`;
+      ms.prependLeft(insertPos, insertion);
+      match = regex.exec(fileContent);
+    }
+  }
+  let result = ms.toString();
+  result = result.replace(/\n{3,}/g, "\n\n").replace(/{\n\n/g, "{\n").replace(/\n\n}/g, "\n}");
+  return result.trim().concat("\n");
+}

package/bin/app/config/cfg-content.d.ts

@@ -0,0 +1,14 @@
+export interface RequiredProjectContent {
+    fileRseConfig: boolean;
+    filePackageJson: boolean;
+}
+/**
+ * Gets information about the project content, separating required and optional elements.
+ */
+export declare function getProjectContent(projectPath: string): Promise<{
+    requiredContent: RequiredProjectContent;
+    optionalContent: {
+        dirNodeModules: boolean;
+        dirGit: boolean;
+    };
+}>;

package/bin/app/config/cfg-content.js

@@ -0,0 +1,15 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { cliConfigJsonc, cliConfigTs } from "./constants.js";
+export async function getProjectContent(projectPath) {
+  const configJSONC = path.join(projectPath, cliConfigJsonc);
+  const configTS = path.join(projectPath, cliConfigTs);
+  const fileRseConfig = await fs.pathExists(configJSONC) || await fs.pathExists(configTS);
+  const filePackageJson = await fs.pathExists(path.join(projectPath, "package.json"));
+  const dirNodeModules = await fs.pathExists(path.join(projectPath, "node_modules"));
+  const dirGit = await fs.pathExists(path.join(projectPath, ".git"));
+  return {
+    requiredContent: { fileRseConfig, filePackageJson },
+    optionalContent: { dirNodeModules, dirGit }
+  };
+}

package/bin/app/config/cfg-core.d.ts

@@ -0,0 +1,14 @@
+import type { RseConfig } from "../types/mod.js";
+/**
+ * Retrieves or creates the main rseg (and any 'mrse' configs).
+ * Allows an optional custom path to the TS config file.
+ */
+export declare function getOrCreateRseConfig({ projectPath, isDev, overrides, customTsconfigPath, }: {
+    projectPath: string;
+    isDev: boolean;
+    overrides: Partial<RseConfig>;
+    customTsconfigPath?: string;
+}): Promise<{
+    config: RseConfig;
+    mrse: RseConfig[];
+}>;

package/bin/app/config/cfg-core.js

@@ -0,0 +1,63 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { createRseConfig } from "./cfg-create.js";
+import { DEFAULT_CONFIG_RSE } from "./cfg-default.js";
+import { getRseConfigPath } from "./cfg-path.js";
+import { readRseConfig } from "./cfg-read.js";
+import { parseAndFixRseConfig } from "./cfg-repair.js";
+import { cliConfigJsonc, cliConfigTs, RSE_SCHEMA_DEV, UNKNOWN_VALUE } from "./constants.js";
+export async function getOrCreateRseConfig({
+  projectPath,
+  isDev,
+  overrides,
+  customTsconfigPath
+}) {
+  const githubUsername = UNKNOWN_VALUE;
+  const mrseFolderPath = path.join(projectPath, ".config", "mrse");
+  const results = [];
+  if (await fs.pathExists(mrseFolderPath)) {
+    const dirItems = await fs.readdir(mrseFolderPath);
+    const rseFiles = dirItems.filter((item) => item === cliConfigJsonc || item === cliConfigTs);
+    const configs = await Promise.all(
+      rseFiles.map(async (file) => {
+        const filePath = path.join(mrseFolderPath, file);
+        let foundConfig = await readRseConfig(filePath, isDev);
+        if (!foundConfig) {
+          foundConfig = await parseAndFixRseConfig(filePath, isDev);
+        }
+        if (!foundConfig) {
+          relinka("warn", `Skipping invalid config file: ${filePath}`);
+        }
+        return foundConfig;
+      })
+    );
+    results.push(...configs.filter((cfg) => cfg !== null));
+  }
+  const { configPath } = await getRseConfigPath(projectPath, isDev, false, customTsconfigPath);
+  if (!await fs.pathExists(configPath)) {
+    await createRseConfig(projectPath, githubUsername, isDev, overrides);
+  } else {
+    const content = (await fs.readFile(configPath, "utf-8")).trim();
+    if (!content || content === "{}") {
+      await createRseConfig(projectPath, githubUsername, isDev, overrides);
+    } else {
+      const validConfig = await readRseConfig(configPath, isDev);
+      if (!validConfig) {
+        const fixed = await parseAndFixRseConfig(configPath, isDev);
+        if (!fixed) {
+          relinka("warn", "Could not fix existing config. Using fallback defaults.");
+        }
+      }
+    }
+  }
+  const mainConfig = await readRseConfig(configPath, isDev);
+  if (!mainConfig) {
+    relinka("warn", "Using fallback default config due to validation failure.");
+    return { config: { ...DEFAULT_CONFIG_RSE }, mrse: results };
+  }
+  if (isDev) {
+    mainConfig.$schema = RSE_SCHEMA_DEV;
+  }
+  return { config: mainConfig, mrse: results };
+}

package/bin/app/config/cfg-create.d.ts

@@ -0,0 +1,35 @@
+import type { DeploymentService, RseConfig } from "../types/mod.js";
+/**
+ * Writes the given rseConfig to the specified config file (TypeScript or JSONC).
+ * Performs an atomic write (using a temp file) and creates a backup of any existing config.
+ * In dev mode, automatically builds a relative path to `sdk-mod.ts`.
+ */
+export declare function writeRseConfig(configPath: string, config: RseConfig, isDev: boolean, skipInstallPrompt?: boolean, customPathToTypes?: string): Promise<void>;
+/**
+ * rse Config Creation (wrapper around config generator and fixer)
+ */
+export declare function createRseConfig(projectPath: string, githubUsername: string, isDev: boolean, overrides: Partial<RseConfig>): Promise<void>;
+/**
+ * Generates a rse config (rseConfig) by merging defaults, existing config, and overrides.
+ * Writes the resulting config to disk (TypeScript or JSONC), optionally skipping install prompts in non-dev mode.
+ */
+export declare function generateRseConfig({ projectName, frontendUsername, deployService, primaryDomain, projectPath, githubUsername, enableI18n, overwrite, isDev, configInfo, customOutputPath, customFilename, skipInstallPrompt, customPathToTypes, overrides, }: {
+    projectName: string;
+    frontendUsername: string;
+    deployService: DeploymentService;
+    primaryDomain: string;
+    projectPath: string;
+    githubUsername: string;
+    enableI18n?: boolean;
+    overwrite?: boolean;
+    isDev: boolean;
+    configInfo?: {
+        configPath: string;
+        isTS: boolean;
+    };
+    customOutputPath?: string;
+    customFilename?: string;
+    skipInstallPrompt?: boolean;
+    customPathToTypes?: string;
+    overrides: Partial<RseConfig>;
+}): Promise<void>;