@reliverse/dler 1.2.3 → 1.2.5

package/bin/app/rempts/migrate/impl/commander.js

@@ -0,0 +1,265 @@
+import { glob } from "glob";
+import {
+  Project,
+  Node,
+  ScriptTarget,
+  ModuleKind,
+  SyntaxKind
+} from "ts-morph";
+function parseCommanderFlags(flags) {
+  const parts = flags.split(/[\s,]+/).filter(Boolean);
+  let longName = "";
+  let shortName;
+  let takesValue = false;
+  for (const part of parts) {
+    if (part.startsWith("--")) {
+      longName = part.substring(2);
+    } else if (part.startsWith("-") && part.length === 2) {
+      shortName = part.substring(1);
+    }
+  }
+  if (flags.includes("<") || flags.includes("[")) {
+    takesValue = true;
+    longName = longName.replace(/[<[].*/, "").trim();
+  }
+  if (!longName && shortName) {
+    if (flags.includes(`<${shortName}>`)) takesValue = true;
+    longName = shortName;
+  }
+  if (!longName) {
+    throw new Error(`Could not parse flags: ${flags}`);
+  }
+  return { longName, shortName, takesValue };
+}
+function getDefaultValueText(node) {
+  if (!node) return void 0;
+  if (Node.isLiteralExpression(node)) {
+    return node.getText();
+  }
+  if (Node.isIdentifier(node) || Node.isPropertyAccessExpression(node)) {
+    return node.getText();
+  }
+  if (Node.isCallExpression(node)) {
+    return node.getText();
+  }
+  if (Node.isPrefixUnaryExpression(node)) {
+    return node.getText();
+  }
+  console.warn(
+    `Unhandled default value type: ${node.getKindName()}, text: ${node.getText()}`
+  );
+  return node.getText();
+}
+async function transformCommand(varDecl, info, sourceFile) {
+  const commandName = info.commandName;
+  if (!commandName) {
+    console.warn("No command name found");
+    return;
+  }
+  let actionBodyText = "";
+  if (info.actionFunction) {
+    if (Node.isArrowFunction(info.actionFunction) || Node.isFunctionExpression(info.actionFunction) || Node.isFunctionDeclaration(info.actionFunction)) {
+      const body = info.actionFunction.getBody();
+      if (body) {
+        actionBodyText = body.getText();
+        if (Node.isBlock(body)) {
+          actionBodyText = actionBodyText.slice(1, -1).trim();
+        }
+      }
+    } else {
+      console.warn(
+        `Unhandled action function type: ${info.actionFunction.getKindName()}`
+      );
+    }
+  }
+  info.options.reverse();
+  if (info.actionFunctionParam) {
+    const paramRegex = new RegExp(`\\b${info.actionFunctionParam}\\b`, "g");
+    actionBodyText = actionBodyText.replace(paramRegex, "args");
+  }
+  const argsProperties = info.options.map((opt) => {
+    const defaultValueStr = opt.defaultValue ? `,
+      default: ${String(opt.defaultValue)}` : "";
+    const requiredStr = opt.required ? ",\n      required: true" : "";
+    return `    ${opt.name}: {
+      type: "${opt.type}",
+      description: "${opt.description}"${defaultValueStr}${requiredStr}
+    }`;
+  }).join(",\n");
+  const defineCommandText = `
+export const ${varDecl.getName()} = defineCommand({
+  meta: {
+    name: "${commandName}",
+    version: "${info.version || "1.0.0"}",
+    description: "${info.description || "Migrated from Commander"}",
+  },
+  args: {
+${argsProperties}
+  },
+  async run({ args }) {
+${actionBodyText}
+  },
+});
+
+// Add runMain at the end of the file
+await runMain(${varDecl.getName()});
+`;
+  varDecl.replaceWithText(defineCommandText);
+  if (info.actionFunction && Node.isIdentifier(info.actionFunction)) {
+    const funcName = info.actionFunction.getText();
+    const funcDecl = sourceFile.getFunction(funcName);
+    if (funcDecl) {
+      funcDecl.remove();
+    }
+  }
+  sourceFile.fixMissingImports();
+  await sourceFile.save();
+  console.log(`Transformed command in: ${sourceFile.getFilePath()}`);
+}
+function extractCommandInfo(node, sourceFile) {
+  const info = {
+    options: []
+  };
+  if (Node.isNewExpression(node)) {
+    const expr = node.getExpression();
+    if (expr && Node.isIdentifier(expr) && expr.getText() === "Command") {
+      const commandArg = node.getArguments()[0];
+      if (commandArg && Node.isStringLiteral(commandArg)) {
+        info.commandName = commandArg.getLiteralText();
+      }
+      return info;
+    }
+  }
+  if (Node.isCallExpression(node)) {
+    let tempExpr = node;
+    while (tempExpr && Node.isCallExpression(tempExpr)) {
+      const expression = tempExpr.getExpression();
+      if (Node.isPropertyAccessExpression(expression)) {
+        const methodName = expression.getName();
+        switch (methodName) {
+          case "action":
+            handleActionMethod(tempExpr, info, sourceFile);
+            break;
+          case "option":
+            handleOptionMethod(tempExpr, info);
+            break;
+          case "description":
+            handleDescriptionMethod(tempExpr, info);
+            break;
+          case "version":
+            handleVersionMethod(tempExpr, info);
+            break;
+        }
+      }
+      const parent = tempExpr.getParent();
+      tempExpr = Node.isCallExpression(parent) ? parent : void 0;
+    }
+    return info;
+  }
+  return void 0;
+}
+function handleActionMethod(node, info, sourceFile) {
+  const [actionArg] = node.getArguments();
+  if (actionArg && Node.isIdentifier(actionArg)) {
+    const funcDef = sourceFile.getFunction(actionArg.getText()) || sourceFile.getVariableDeclaration(actionArg.getText())?.getInitializer();
+    if (funcDef && (Node.isArrowFunction(funcDef) || Node.isFunctionDeclaration(funcDef) || Node.isFunctionExpression(funcDef))) {
+      info.actionFunction = funcDef;
+      const firstParam = funcDef.getParameters()[0];
+      if (firstParam) {
+        info.actionFunctionParam = firstParam.getName();
+      }
+    }
+  }
+}
+function handleOptionMethod(node, info) {
+  const [flagsArg, descArg, defaultValueArg] = node.getArguments();
+  if (flagsArg && Node.isStringLiteral(flagsArg)) {
+    const { longName, shortName, takesValue } = parseCommanderFlags(
+      flagsArg.getLiteralText()
+    );
+    info.options.push({
+      name: longName,
+      shortFlag: shortName,
+      type: takesValue ? "string" : "boolean",
+      description: Node.isStringLiteral(descArg) ? descArg.getLiteralText() : "TODO: Add description",
+      defaultValue: defaultValueArg ? getDefaultValueText(defaultValueArg) : void 0
+    });
+  }
+}
+function handleDescriptionMethod(node, info) {
+  const [descArg] = node.getArguments();
+  if (descArg && Node.isStringLiteral(descArg)) {
+    info.description = descArg.getLiteralText();
+  }
+}
+function handleVersionMethod(node, info) {
+  const [versionArg] = node.getArguments();
+  if (versionArg && Node.isStringLiteral(versionArg)) {
+    info.version = versionArg.getLiteralText();
+  }
+}
+export async function commanderToRempts(targetDirectory) {
+  if (!targetDirectory) {
+    throw new Error("Target directory is required");
+  }
+  const project = new Project({
+    compilerOptions: {
+      target: ScriptTarget.ESNext,
+      module: ModuleKind.ESNext,
+      esModuleInterop: true,
+      skipLibCheck: true
+    },
+    skipAddingFilesFromTsConfig: true
+  });
+  const filePaths = await glob(`${targetDirectory}/**/*.ts`, {
+    ignore: ["**/node_modules/**", "**/*.d.ts"],
+    absolute: true
+  });
+  for (const filePath of filePaths) {
+    console.log(`Processing: ${filePath}`);
+    project.addSourceFileAtPath(filePath);
+    try {
+      await transformFile(filePath, project);
+    } catch (error) {
+      console.error(`Error transforming file ${filePath}:`, error);
+    }
+  }
+  console.log("Migration completed successfully.");
+}
+async function transformFile(filePath, project) {
+  const sourceFile = project.getSourceFile(filePath);
+  if (!sourceFile) {
+    console.error(`Could not find source file: ${filePath}`);
+    return;
+  }
+  const commanderImport = sourceFile.getImportDeclaration("commander");
+  if (commanderImport) {
+    commanderImport.remove();
+  }
+  const remptsImport = sourceFile.getImportDeclaration("@reliverse/rempts");
+  const neededRemptsImports = ["defineCommand", "runMain"];
+  if (remptsImport) {
+    const existingNamedImports = remptsImport.getNamedImports().map((ni) => ni.getName());
+    for (const neededImport of neededRemptsImports) {
+      if (!existingNamedImports.includes(neededImport)) {
+        remptsImport.addNamedImport(neededImport);
+      }
+    }
+  } else {
+    sourceFile.addImportDeclaration({
+      moduleSpecifier: "@reliverse/rempts",
+      namedImports: neededRemptsImports
+    });
+  }
+  const variableDeclarations = sourceFile.getDescendantsOfKind(
+    SyntaxKind.VariableDeclaration
+  );
+  for (const varDecl of variableDeclarations) {
+    const initializer = varDecl.getInitializer();
+    if (!initializer) continue;
+    const commandInfo = extractCommandInfo(initializer, sourceFile);
+    if (commandInfo) {
+      await transformCommand(varDecl, commandInfo, sourceFile);
+    }
+  }
+}

package/bin/init.js

@@ -164,6 +164,10 @@ export default defineConfig({
   transpileStub: ${DEFAULT_CONFIG.transpileStub},
   transpileTarget: "${DEFAULT_CONFIG.transpileTarget}",
   transpileWatch: ${DEFAULT_CONFIG.transpileWatch},
+
+  // Additionals
+  injectComment: "${DEFAULT_CONFIG.injectComment}",
+  tscCommand: "${DEFAULT_CONFIG.tscCommand}",
 });
 `;
   return configTemplate;

package/bin/libs/cfg/cfg-default.js

@@ -47,5 +47,7 @@ export const DEFAULT_CONFIG = {
   transpileSplitting: false,
   transpileStub: false,
   transpileTarget: "node",
-  transpileWatch: false
+  transpileWatch: false,
+  injectComment: "// @ts-expect-error TODO: fix ts",
+  tscCommand: "tsc --project ./tsconfig.json --noEmit"
 };

package/package.json

@@ -2,7 +2,7 @@
   "dependencies": {
     "@reliverse/relico": "^1.1.2",
     "@reliverse/relinka": "^1.4.5",
-    "@reliverse/rempts": "^1.7.4",
+    "@reliverse/rempts": "^1.7.10",
     "@rollup/plugin-alias": "^5.1.1",
     "@rollup/plugin-commonjs": "^28.0.3",
     "@rollup/plugin-json": "^6.1.0",
@@ -33,6 +33,7 @@
     "scule": "^1.3.0",
     "semver": "^7.7.2",
     "tinyglobby": "^0.2.13",
+    "ts-morph": "^25.0.1",
     "untyped": "^2.0.0"
   },
   "description": "dler (prev. relidler) is a flexible, unified, and fully automated bundler for TypeScript and JavaScript projects, as well as an NPM and JSR publishing tool.",
@@ -40,7 +41,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "keywords": [
     "reliverse",
     "cli",

package/bin/app/inject/impl/arg-ts-expect-error.txt

@@ -1,49 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { defineCommand } from "@reliverse/rempts";
-
-import { useTsExpectError } from "./ts-expect-error.js";
-
-export default defineCommand({
-  meta: {
-    name: "tee",
-    description: "Inject `@ts-expect-error` above lines where TS errors occur",
-  },
-  args: {
-    dev: {
-      type: "boolean",
-      description: "Run the CLI in dev mode",
-    },
-    files: {
-      type: "positional",
-      // array: true, // TODO: implement in dler
-      required: true,
-      description: `'auto' or path(s) to line references file(s)`,
-    },
-    comment: {
-      type: "string",
-      required: false,
-      description:
-        "Override the comment line to insert. Default is `// @ts-expect-error TODO: fix ts`",
-    },
-    tscPaths: {
-      type: "string",
-      // array: true,
-      required: false,
-      description:
-        "Optional: specify path(s) to restrict TSC processing (only effective when using 'auto')",
-    },
-  },
-  run: async ({ args }) => {
-    if (args.dev) {
-      relinka("verbose", "Using dev mode");
-    }
-
-    await useTsExpectError({
-      files: [args.files],
-      comment: args.comment,
-      tscPaths: [args.tscPaths],
-    });
-
-    process.exit(0);
-  },
-});

package/bin/app/inject/impl/inject-mod.txt

@@ -1,28 +0,0 @@
-// todo: implement
-import { defineCommand, errorHandler, runMain } from "@reliverse/rempts";
-
-const main = defineCommand({
-  meta: {
-    name: "reinject",
-    version: "1.0.0",
-    description: "@reliverse/reinject-cli",
-  },
-  args: {
-    dev: {
-      type: "boolean",
-      description: "Runs the CLI in dev mode",
-    },
-  },
-  subCommands: {
-    cli: () => import("./cli/cli-mod.js").then((r) => r.default),
-    tee: () =>
-      import("./cli/args/arg-ts-expect-error.js").then((r) => r.default),
-  },
-});
-
-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/reinject",
-  );
-});

package/bin/app/inject/impl/reinject.config.js

@@ -1,4 +0,0 @@
-export default {
-  injectComment: "// @ts-expect-error TODO: fix ts",
-  tscCommand: "tsc --project ./tsconfig.json --noEmit"
-};

package/bin/app/inject/impl/ts-expect-error.txt

@@ -1,277 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { loadConfig } from "c12";
-import { execa } from "execa";
-import fs from "fs-extra";
-import path from "pathe";
-
-//-------------------------------------
-// 1) c12 config interface
-//-------------------------------------
-type ReinjectUserConfig = {
-  // The comment to inject above each error line
-  injectComment?: string;
-  // The command used to spawn tsc (e.g. "tsc --noEmit --project tsconfig.json")
-  tscCommand?: string;
-};
-
-//-------------------------------------
-// 2) Load c12 configs
-//-------------------------------------
-async function loadReinjectConfig(): Promise<ReinjectUserConfig> {
-  const { config } = await loadConfig<ReinjectUserConfig>({
-    name: "reinject", // tries reinject.config.*, .reinjectrc, etc.
-    defaults: {},
-    overrides: {},
-    dotenv: false,
-    packageJson: false,
-  });
-
-  return {
-    injectComment: config.injectComment ?? "// @ts-expect-error TODO: fix ts",
-    tscCommand: config.tscCommand ?? "tsc --noEmit",
-  };
-}
-
-//-------------------------------------
-// Helper: Parse command string into command and arguments
-//-------------------------------------
-function parseCommand(command: string): { cmd: string; args: string[] } {
-  // This parser splits the command by whitespace while handling double or single quotes.
-  const regex = /"([^"]+)"|'([^']+)'|(\S+)/g;
-  const args: string[] = [];
-  let match: RegExpExecArray | null;
-  while ((match = regex.exec(command)) !== null) {
-    args.push(match[1] || match[2] || match[3]);
-  }
-  const cmd = args.shift() || "";
-  return { cmd, args };
-}
-
-//-------------------------------------
-// 3) parseLineRefs from a lines file
-//-------------------------------------
-async function parseLinesFile(linesFile: string) {
-  const fileContents = await fs.readFile(linesFile, "utf-8");
-  const splitted = fileContents.split(/\r?\n/);
-  const results: { filePath: string; lineNumber: number }[] = [];
-
-  for (const rawLine of splitted) {
-    const trimmed = rawLine.trim();
-    if (!trimmed) continue;
-
-    // Could match "N  path.ts:line"
-    let match = trimmed.match(/^(\d+)\s+(.+?):(\d+)$/);
-    if (match) {
-      results.push({
-        filePath: match[2],
-        lineNumber: Number.parseInt(match[3], 10),
-      });
-      continue;
-    }
-
-    // Or "path.ts:line"
-    match = trimmed.match(/^(.+?):(\d+)$/);
-    if (match) {
-      results.push({
-        filePath: match[1],
-        lineNumber: Number.parseInt(match[2], 10),
-      });
-    } else {
-      relinka("warn", `Line doesn't match expected format: ${trimmed}`);
-    }
-  }
-  return results;
-}
-
-//-------------------------------------
-// 4) runTscAndParseErrors: run tsc with execa, parse error lines
-// Example TSC error line format:
-//   src/foo.ts(12,5): error TS2322:
-// We'll capture `src/foo.ts` and `12` as the error line number
-//-------------------------------------
-async function runTscAndParseErrors(
-  tscCommand: string,
-  tscPaths?: string[],
-): Promise<{ filePath: string; lineNumber: number }[]> {
-  const linesRefs: { filePath: string; lineNumber: number }[] = [];
-
-  try {
-    // Parse the TSC command into the command and its arguments.
-    const { cmd, args: cmdArgs } = parseCommand(tscCommand);
-    // Append any additional paths (if provided) as extra arguments.
-    if (tscPaths && tscPaths.length > 0) {
-      cmdArgs.push(...tscPaths);
-    }
-
-    // Run TSC.
-    const subprocess = await execa(cmd, cmdArgs, { all: true, reject: false });
-    const combinedOutput = subprocess.all || "";
-    const splitted = combinedOutput.split(/\r?\n/);
-    const regex = /^(.+?)\((\d+),(\d+)\): error TS\d+: /;
-
-    for (const line of splitted) {
-      const trimmed = line.trim();
-      const m = trimmed.match(regex);
-      if (m) {
-        let file = m[1];
-        const row = Number.parseInt(m[2], 10);
-        if (row > 0) {
-          // Normalize Windows paths.
-          file = file.replace(/\\/g, "/");
-          linesRefs.push({
-            filePath: file,
-            lineNumber: row,
-          });
-        }
-      }
-    }
-  } catch (error: any) {
-    // In case of error, try to extract the output.
-    const combined = (error.all as string) || "";
-    if (!combined) {
-      relinka("log", `TSC returned no error lines. Possibly no TS errors?`);
-      return [];
-    }
-
-    const splitted = combined.split(/\r?\n/);
-    const regex = /^(.+?)\((\d+),(\d+)\): error TS\d+: /;
-
-    for (const line of splitted) {
-      const m = line.trim().match(regex);
-      if (m) {
-        let file = m[1];
-        const row = Number.parseInt(m[2], 10);
-        if (row > 0) {
-          file = file.replace(/\\/g, "/");
-          linesRefs.push({ filePath: file, lineNumber: row });
-        }
-      }
-    }
-  }
-
-  return linesRefs;
-}
-
-//-------------------------------------
-// Helper: Check if file is within any of the provided directories
-//-------------------------------------
-function isWithin(filePath: string, dirs: string[]): boolean {
-  const absFile = path.resolve(filePath);
-  for (const dir of dirs) {
-    const absDir = path.resolve(dir);
-    // Ensure trailing separator for accurate prefix matching
-    const normalizedDir = absDir.endsWith(path.sep)
-      ? absDir
-      : absDir + path.sep;
-    if (absFile.startsWith(normalizedDir)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-//-------------------------------------
-// 5) The injection logic
-//-------------------------------------
-async function injectCommentIntoFiles(
-  linesRecords: { filePath: string; lineNumber: number }[],
-  commentText: string,
-) {
-  // Group error lines by file
-  const byFile = new Map<string, number[]>();
-  for (const rec of linesRecords) {
-    if (!byFile.has(rec.filePath)) {
-      byFile.set(rec.filePath, []);
-    }
-    byFile.get(rec.filePath)!.push(rec.lineNumber);
-  }
-
-  for (const [filePath, lineNums] of byFile.entries()) {
-    // Sort descending so injections don't affect subsequent line numbers
-    lineNums.sort((a, b) => b - a);
-    const absPath = path.resolve(filePath);
-    relinka(
-      "log",
-      `Injecting into ${absPath} at lines: ${lineNums.join(", ")}`,
-    );
-
-    try {
-      const original = await fs.readFile(absPath, "utf-8");
-      const splitted = original.split(/\r?\n/);
-      for (const ln of lineNums) {
-        if (ln <= splitted.length) {
-          splitted.splice(ln - 1, 0, commentText);
-        } else {
-          relinka("warn", `Line ${ln} exceeds file length for ${absPath}`);
-        }
-      }
-      const newContent = splitted.join("\n");
-      await fs.writeFile(absPath, newContent, "utf-8");
-    } catch (error) {
-      relinka("error", `Failed editing ${filePath}: ${error}`);
-    }
-  }
-}
-
-//-------------------------------------
-// 6) The main usage function
-//-------------------------------------
-export async function useTsExpectError(args: {
-  files: string[];
-  comment?: string;
-  tscPaths?: string[];
-}) {
-  // 1) load c12 config
-  const userConfig = await loadReinjectConfig();
-  const finalComment = args.comment || userConfig.injectComment!;
-
-  // Gather references
-  const lines: { filePath: string; lineNumber: number }[] = [];
-  let usedAuto = false;
-  for (const item of args.files) {
-    if (item.toLowerCase() === "auto") {
-      usedAuto = true;
-    }
-  }
-
-  if (usedAuto) {
-    relinka("log", "Running TSC to discover error lines...");
-    const tscCommand = userConfig.tscCommand!;
-    try {
-      const discovered = await runTscAndParseErrors(tscCommand, args.tscPaths);
-      // If tscPaths are provided, filter discovered errors to include only files within those paths.
-      if (args.tscPaths && args.tscPaths.length > 0) {
-        const filtered = discovered.filter((rec) =>
-          isWithin(rec.filePath, args.tscPaths!),
-        );
-        lines.push(...filtered);
-      } else {
-        lines.push(...discovered);
-      }
-    } catch (error) {
-      relinka("error", `Failed running tsc: ${error}`);
-      process.exit(1);
-    }
-  }
-
-  // Parse lines from each file that isn't "auto"
-  for (const item of args.files) {
-    if (item.toLowerCase() === "auto") continue;
-
-    try {
-      const recs = await parseLinesFile(item);
-      lines.push(...recs);
-    } catch (error) {
-      relinka("error", `Failed reading lines file ${item}: ${error}`);
-    }
-  }
-
-  if (lines.length === 0) {
-    relinka("error", "No references found. Nothing to do.");
-    relinka("error", "Lines: ", JSON.stringify(lines));
-    process.exit(1);
-  }
-
-  await injectCommentIntoFiles(lines, finalComment);
-  relinka("success", "All lines processed successfully.");
-}