@reliverse/dler 1.2.2 → 1.2.4

package/bin/{cli/args/init/init-mod.txt → app/relifso/init/cmd.js}

@@ -1,121 +1,93 @@
-import { relinka } from "@reliverse/relinka";
-import {
-  defineCommand,
-  errorHandler,
-  multiselectPrompt,
-  runMain,
-  selectPrompt,
-} from "@reliverse/rempts";
-
-import type {
-  FileType,
-  InitFileRequest,
-} from "./libs/reinit/reint-impl/types.js";
-
-import { FILE_TYPES } from "./libs/reinit/reint-impl/const.js";
-import { initFile, initFiles } from "./libs/reinit/reint-impl/mod.js";
-
-const main = defineCommand({
-  meta: {
-    name: "reinit",
-    version: "1.0.0",
-    description: "@reliverse/reinit-cli",
-  },
-  args: {
-    dev: {
-      type: "boolean",
-      description: "Runs the CLI in dev mode",
-    },
-    fileType: {
-      type: "string",
-      description: "File type to initialize (e.g. 'md:README')",
-      required: false,
-    },
-    destDir: {
-      type: "string",
-      description: "Destination directory",
-      default: ".",
-      required: false,
-    },
-    multiple: {
-      type: "boolean",
-      description: "Whether to select multiple file types from the library",
-      required: false,
-      default: false,
-    },
-    parallel: {
-      type: "boolean",
-      description: "Run tasks in parallel",
-      required: false,
-      default: false,
-    },
-    concurrency: {
-      type: "string",
-      description: "Concurrency limit if parallel is true",
-      required: false,
-      default: "4",
-    },
-  },
-  async run({ args }) {
-    const { fileType, destDir, multiple, parallel, concurrency } = args;
-    const concurrencyNum = Number(concurrency);
-
-    // throw error if fileType doesn't include FILE_TYPES.type
-    if (fileType && !FILE_TYPES.find((ft) => ft.type === fileType)) {
-      throw new Error(`Invalid file type: ${fileType}`);
-    }
-
-    const effectiveFileType: FileType = fileType as FileType;
-
-    if (multiple) {
-      // Let the user choose multiple file types from a prompt
-      const possibleTypes = FILE_TYPES.map((ft) => ft.type);
-      const chosen = await multiselectPrompt({
-        title: "Select file types to initialize",
-        options: possibleTypes.map((pt) => ({ label: pt, value: pt })),
-      });
-
-      if (chosen.length === 0) {
-        relinka("log", "No file types selected. Exiting...");
-        return;
-      }
-
-      // Construct an array of requests
-      const requests: InitFileRequest[] = chosen.map((ct) => ({
-        fileType: ct,
-        destDir,
-      }));
-
-      const results = await initFiles(requests, {
-        parallel,
-        concurrency: concurrencyNum,
-      });
-      relinka("verbose", `Multiple files result: ${JSON.stringify(results)}`);
-    } else {
-      // Single file approach
-      let finalFileType = effectiveFileType;
-      if (!finalFileType) {
-        // If user didn't specify, prompt for a single file type
-        const possibleTypes = FILE_TYPES.map((ft) => ft.type);
-        const picked = await selectPrompt({
-          title: "Pick a file type to initialize",
-          options: possibleTypes.map((pt) => ({ label: pt, value: pt })),
-        });
-        finalFileType = picked;
-      }
-
-      const result = await initFile({
-        fileType: finalFileType,
-        destDir,
-      });
-      relinka("verbose", `Single file result: ${JSON.stringify(result)}`);
-    }
-  },
-});
-
-await runMain(main).catch((error: unknown) => {
-  errorHandler(
-    error instanceof Error ? error : new Error(String(error)),
-    "An unhandled error occurred, please report it at https://github.com/reliverse/reinit",
-  );
-});
+import { relinka } from "@reliverse/relinka";
+import {
+  defineCommand,
+  multiselectPrompt,
+  selectPrompt
+} from "@reliverse/rempts";
+import { FILE_TYPES } from "./impl/const.js";
+import { initFile, initFiles } from "./impl/mod.js";
+export default defineCommand({
+  meta: {
+    name: "relifso",
+    version: "1.0.0",
+    description: "relifso helper utils"
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Runs the CLI in dev mode"
+    },
+    fileType: {
+      type: "string",
+      description: "File type to initialize (e.g. 'md:README')",
+      required: false
+    },
+    destDir: {
+      type: "string",
+      description: "Destination directory",
+      default: ".",
+      required: false
+    },
+    multiple: {
+      type: "boolean",
+      description: "Whether to select multiple file types from the library",
+      required: false,
+      default: false
+    },
+    parallel: {
+      type: "boolean",
+      description: "Run tasks in parallel",
+      required: false,
+      default: false
+    },
+    concurrency: {
+      type: "string",
+      description: "Concurrency limit if parallel is true",
+      required: false,
+      default: "4"
+    }
+  },
+  async run({ args }) {
+    const { fileType, destDir, multiple, parallel, concurrency } = args;
+    const concurrencyNum = Number(concurrency);
+    if (fileType && !FILE_TYPES.find((ft) => ft.type === fileType)) {
+      throw new Error(`Invalid file type: ${fileType}`);
+    }
+    const effectiveFileType = fileType;
+    if (multiple) {
+      const possibleTypes = FILE_TYPES.map((ft) => ft.type);
+      const chosen = await multiselectPrompt({
+        title: "Select file types to initialize",
+        options: possibleTypes.map((pt) => ({ label: pt, value: pt }))
+      });
+      if (chosen.length === 0) {
+        relinka("log", "No file types selected. Exiting...");
+        return;
+      }
+      const requests = chosen.map((ct) => ({
+        fileType: ct,
+        destDir
+      }));
+      const results = await initFiles(requests, {
+        parallel,
+        concurrency: concurrencyNum
+      });
+      relinka("verbose", `Multiple files result: ${JSON.stringify(results)}`);
+    } else {
+      let finalFileType = effectiveFileType;
+      if (!finalFileType) {
+        const possibleTypes = FILE_TYPES.map((ft) => ft.type);
+        const picked = await selectPrompt({
+          title: "Pick a file type to initialize",
+          options: possibleTypes.map((pt) => ({ label: pt, value: pt }))
+        });
+        finalFileType = picked;
+      }
+      const result = await initFile({
+        fileType: finalFileType,
+        destDir
+      });
+      relinka("verbose", `Single file result: ${JSON.stringify(result)}`);
+    }
+  }
+});

package/bin/app/relifso/init/impl/mod.js

@@ -0,0 +1,248 @@
+import { relinka } from "@reliverse/relinka";
+import { selectPrompt } from "@reliverse/rempts";
+import fs from "fs-extra";
+import pMap from "p-map";
+import path from "pathe";
+import { FILE_TYPES } from "./const.js";
+import { gitignoreTemplate } from "./templates/t-gitignore.js";
+import { licenseTemplate } from "./templates/t-license.js";
+import { readmeTemplate } from "./templates/t-readme.js";
+import { escapeMarkdownCodeBlocks } from "./utils.js";
+const DEFAULT_CONFIG = {
+  defaultInitBehaviour: "create",
+  defaultDestFileExistsBehaviour: "prompt",
+  parallelByDefault: false,
+  parallelConcurrency: 4
+};
+const fileExistsCache = /* @__PURE__ */ new Map();
+export async function createFileFromScratch(destPath, fileType, contentCreateMode) {
+  try {
+    await fs.ensureDir(path.dirname(destPath));
+    let content = "";
+    switch (fileType) {
+      case "md:LICENSE":
+        content = licenseTemplate;
+        break;
+      case "md:README":
+        content = escapeMarkdownCodeBlocks(readmeTemplate);
+        break;
+      case "git:gitignore":
+        content = gitignoreTemplate;
+        break;
+      default:
+        content = `// Auto-generated file for type: ${fileType}`;
+        break;
+    }
+    if (contentCreateMode) {
+      content = contentCreateMode;
+      relinka("verbose", `Using custom content for file ${destPath}`);
+    }
+    await fs.outputFile(destPath, content, { encoding: "utf-8" });
+  } catch (error) {
+    relinka("error", `Failed to create file ${destPath}: ${error}`);
+    throw error;
+  }
+}
+export async function initFile(req, userCfg) {
+  const config = { ...DEFAULT_CONFIG, ...userCfg };
+  const initBehaviour = req.initBehaviour ?? config.defaultInitBehaviour;
+  const existsBehaviour = req.destFileExistsBehaviour ?? config.defaultDestFileExistsBehaviour;
+  config.onFileStart?.(req);
+  let result;
+  try {
+    result = await doInitFile(
+      req,
+      initBehaviour,
+      existsBehaviour
+    );
+  } catch (err) {
+    result = {
+      requested: req,
+      status: "error",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  config.onFileComplete?.(result);
+  return result;
+}
+export async function initFiles(items, options, userCfg) {
+  const config = { ...DEFAULT_CONFIG, ...userCfg };
+  const parallel = options?.parallel ?? config.parallelByDefault;
+  const concurrency = options?.concurrency ?? config.parallelConcurrency;
+  if (parallel) {
+    return pMap(items, (item) => initFile(item, config), { concurrency });
+  }
+  return Promise.all(items.map((item) => initFile(item, config)));
+}
+async function checkFileExists(filePath) {
+  const cached = fileExistsCache.get(filePath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const exists = await fs.pathExists(filePath);
+  fileExistsCache.set(filePath, exists);
+  return exists;
+}
+async function doInitFile(req, initBehaviour, destFileExistsBehaviour) {
+  const { fileType, destDir, options } = req;
+  const { destFileName } = options ?? {};
+  const knownType = FILE_TYPES.find(
+    (f) => f.type.toLowerCase() === fileType.toLowerCase()
+  );
+  if (!knownType) {
+    throw new Error(`Unknown file type: ${fileType}`);
+  }
+  const variations = knownType.variations;
+  const chosenVariation = variations.length === 1 ? variations[0] : await selectPrompt({
+    title: `Select variation for ${fileType}`,
+    options: variations.map((v) => ({ label: v, value: v }))
+  });
+  const finalName = destFileName ?? chosenVariation;
+  const absoluteDestDir = path.resolve(process.cwd(), destDir || "");
+  const resolvedDestPath = path.join(absoluteDestDir, finalName);
+  relinka(
+    "verbose",
+    `Preparing to init file:
+  - File Type: ${fileType}
+  - Variation: ${chosenVariation}
+  - Destination Dir: ${absoluteDestDir}
+  - Final Path: ${resolvedDestPath}
+  `
+  );
+  const alreadyExists = await checkFileExists(resolvedDestPath);
+  if (alreadyExists) {
+    const maybeNewDest = await handleExistingFile(
+      resolvedDestPath,
+      destFileExistsBehaviour
+    );
+    if (!maybeNewDest) {
+      return { requested: req, status: "skipped" };
+    }
+    if (maybeNewDest !== resolvedDestPath) {
+      relinka("log", `Using new path: ${maybeNewDest}`);
+      return finalizeInit(req, initBehaviour, chosenVariation, maybeNewDest);
+    }
+  }
+  return finalizeInit(req, initBehaviour, chosenVariation, resolvedDestPath);
+}
+async function finalizeInit(req, initBehaviour, chosenVariation, resolvedDestPath) {
+  try {
+    switch (initBehaviour) {
+      case "copy":
+        return await runCopy(req, chosenVariation, resolvedDestPath);
+      case "create":
+        return await runCreate(req, resolvedDestPath);
+      default:
+        try {
+          return await runCopy(req, chosenVariation, resolvedDestPath);
+        } catch {
+          relinka(
+            "warn",
+            `Copy failed for ${chosenVariation}, falling back to create...`
+          );
+          return await runCreate(req, resolvedDestPath);
+        }
+    }
+  } catch (err) {
+    return {
+      requested: req,
+      status: "error",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function runCopy(req, chosenVariation, resolvedDestPath) {
+  const { srcCopyMode, fallbackSource } = req.options ?? {};
+  const resolvedSrcDir = path.resolve(process.cwd(), srcCopyMode || "");
+  try {
+    const srcPath = path.join(resolvedSrcDir, chosenVariation);
+    if (await checkFileExists(srcPath)) {
+      await fs.copy(srcPath, resolvedDestPath);
+      return {
+        requested: req,
+        finalPath: resolvedDestPath,
+        status: "copied"
+      };
+    }
+    if (fallbackSource) {
+      const fallbackPath = path.join(
+        path.resolve(process.cwd(), fallbackSource),
+        chosenVariation
+      );
+      if (await checkFileExists(fallbackPath)) {
+        await fs.copy(fallbackPath, resolvedDestPath);
+        return {
+          requested: req,
+          finalPath: resolvedDestPath,
+          status: "copied"
+        };
+      }
+    }
+    throw new Error(`Source file not found: ${chosenVariation}`);
+  } catch (error) {
+    throw new Error(
+      `Copy failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function runCreate(req, resolvedDestPath) {
+  try {
+    const { contentCreateMode } = req.options ?? {};
+    await createFileFromScratch(
+      resolvedDestPath,
+      req.fileType,
+      contentCreateMode
+    );
+    return {
+      requested: req,
+      finalPath: resolvedDestPath,
+      status: "created"
+    };
+  } catch (error) {
+    throw new Error(
+      `Create failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function handleExistingFile(destPath, behaviour) {
+  switch (behaviour) {
+    case "rewrite":
+      return destPath;
+    case "skip":
+      return null;
+    case "attach-index":
+      return attachIndex(destPath);
+    case "prompt": {
+      const action = await selectPrompt({
+        title: `File ${destPath} already exists`,
+        options: [
+          { label: "Skip", value: "skip" },
+          { label: "Rewrite", value: "rewrite" },
+          { label: "Attach Index", value: "attach-index" }
+        ]
+      });
+      switch (action) {
+        case "skip":
+          return null;
+        case "rewrite":
+          return destPath;
+        case "attach-index":
+          return attachIndex(destPath);
+        default:
+          return null;
+      }
+    }
+  }
+}
+async function attachIndex(originalPath) {
+  const dir = path.dirname(originalPath);
+  const ext = path.extname(originalPath);
+  const base = path.basename(originalPath, ext);
+  let index = 1;
+  let newPath;
+  do {
+    newPath = path.join(dir, `${base}-${index}${ext}`);
+    index++;
+  } while (await checkFileExists(newPath));
+  return newPath;
+}

package/bin/{cli/args/init/cmd/index.js → app/rempts/init/cmd/cmd.js}

@@ -12,7 +12,8 @@ export default defineCommand({
     cmd: {
       type: "array",
       required: true,
-      description: "Names of commands to initialize"
+      description: "Names of commands to initialize",
+      options: ["cmd1", "cmd2", "cmd3"]
     },
     force: {
       type: "boolean",
@@ -21,7 +22,7 @@ export default defineCommand({
     }
   },
   async run({ args }) {
-    const root = path.resolve("src/cli/args");
+    const root = path.resolve("src/app");
     for (const cmdName of args.cmd) {
       const dirPath = path.join(root, cmdName);
       const filePath = path.join(dirPath, "index.ts");

package/bin/app/rempts/init/cmds/cmd.js

@@ -0,0 +1,80 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import fs from "fs-extra";
+import path from "pathe";
+export default defineCommand({
+  meta: {
+    name: "cmds",
+    version: "1.0.0",
+    description: "Generate command exports file for cmd.ts files."
+  },
+  args: {
+    outFile: {
+      type: "string",
+      description: "Output file path (relative to workspace root)",
+      default: "src/app/cmds.ts"
+    },
+    cmdDirs: {
+      type: "array",
+      description: "Command directories to scan (relative to src/app)",
+      default: [],
+      options: ["relifso", "inject", "rempts"]
+    },
+    force: {
+      type: "boolean",
+      default: false,
+      description: "Overwrite existing file"
+    }
+  },
+  async run({ args }) {
+    const root = path.resolve("src/app");
+    const outPath = path.resolve(args.outFile ?? "src/app/cmds.ts");
+    if (await fs.pathExists(outPath) && !args.force) {
+      relinka(
+        "warn",
+        `\u274C File "${outPath}" already exists. Use --force to overwrite.`
+      );
+      return;
+    }
+    const cmdDirs = (args.cmdDirs ?? []).length > 0 ? args.cmdDirs ?? [] : await findCommandDirs(root);
+    if (cmdDirs.length === 0) {
+      relinka("warn", "No command directories found with cmd.ts files.");
+      return;
+    }
+    const exports = generateExports(cmdDirs);
+    await fs.ensureDir(path.dirname(outPath));
+    await fs.writeFile(outPath, exports, "utf-8");
+    relinka("success", `\u2705 Generated command exports at: ${outPath}`);
+    relinka("log", `Found ${cmdDirs.length} command(s): ${cmdDirs.join(", ")}`);
+  }
+});
+async function findCommandDirs(root) {
+  const cmdDirs = [];
+  async function scan(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (await fs.pathExists(path.join(fullPath, "cmd.ts"))) {
+          const relPath = path.relative(root, fullPath);
+          cmdDirs.push(relPath);
+        } else {
+          await scan(fullPath);
+        }
+      }
+    }
+  }
+  await scan(root);
+  return cmdDirs;
+}
+function generateExports(cmdDirs) {
+  const imports = cmdDirs.map((dir) => {
+    const funcName = `getCmd${dir.split(/[/\\]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("")}`;
+    return `export async function ${funcName}() {
+  return (await import("./${dir}/cmd.js")).default;
+}`;
+  });
+  return `// Generated command exports - DO NOT EDIT
+${imports.join("\n\n")}
+`;
+}

package/bin/{cli/args/tools/index.js → app/tools/cmd.js}

@@ -1,7 +1,7 @@
 import { relinka } from "@reliverse/relinka";
 import { defineCommand } from "@reliverse/rempts";
 import path from "pathe";
-import { printUsage, useAggregator } from "./tools-impl.js";
+import { printUsage, useAggregator } from "./impl.js";
 const TOOLS = ["agg"];
 export default defineCommand({
   meta: {