@reliverse/dler 1.2.4 → 1.2.5

package/README.md

@@ -116,7 +116,7 @@ bun dev # bun src/mod.ts --dev
 
 ## 🔌 plugins
 
-dler ships with a flexible plugin system and **15 built-in plugins** (from [@reliverse/addons](https://reliverse.org/addons)).
+dler ships with a flexible plugin system and **14 built-in plugins** (from [@reliverse/addons](https://reliverse.org/addons)).
 
 feel free to create your own plugins. plugins can be implemented as built-in directly in `src/app/plugin-name/impl/*` and then imported from `src/app/plugin-name/cmd.ts`; or implemented in your own library and then imported from `src/app/plugin-name/cmd.ts`.
 
@@ -128,15 +128,7 @@ generates aggregator file with content like `import { getsomething } from "./uti
 dler agg ...
 ```
 
-### 2. `auth`
-
-best friend of auth+db libs like [better-auth](https://better-auth.com) and [drizzle-orm](https://orm.drizzle.team).
-
-```bash
-dler auth better-auth generate
-```
-
-### 3. `build`
+### 2. `build`
 
 since dler is fully modular, build command is separated for its own build-in plugin as well.
 
@@ -144,11 +136,11 @@ since dler is fully modular, build command is separated for its own build-in plu
 dler build ...
 ```
 
-### 4. `conv`
+### 3. `conv`
 
 not yet documented.
 
-### 5. `deps`
+### 4. `deps`
 
 finds missing dependencies in your project by scanning your code for imports and comparing them to your `package.json`.
 
@@ -195,11 +187,11 @@ dler deps --all --directory ./src --include-builtins
 missing dependencies are shown only once, even if used in multiple files.  
 deep imports like `dep/some/file` or `@org/dep/some/thing` are always resolved to their root package.
 
-### 6. `inject`
+### 5. `inject`
 
 not yet documented.
 
-### 7. `libs`
+### 6. `libs`
 
 builds and publishes specific subdirectories of your main project as standalone packages.
 
@@ -235,15 +227,15 @@ libslist: {
 
 - more magic commands coming soon...
 
-### 8. `merge`
+### 7. `merge`
 
 not yet documented.
 
-### 9. `mono`
+### 8. `mono`
 
 not yet documented.
 
-### 10. `pub`
+### 9. `pub`
 
 pub command is separated for its own build-in plugin as well.
 
@@ -253,13 +245,13 @@ it already calls build command by itself, so you don't need to run `dler build`
 dler pub ...
 ```
 
-### 11. `relifso`
+### 10. `relifso`
 
 ```bash
 dler relifso init ...
 ```
 
-### 12. `relinka`
+### 11. `relinka`
 
 @reliverse/relinka's best friend. learn more in its [docs](https://github.com/reliverse/relinka).
 
@@ -267,7 +259,7 @@ dler relifso init ...
 dler relinka --console-to-relinka
 ```
 
-### 13. `rempts`
+### 12. `rempts`
 
 @reliverse/rempts's best friend. learn more in its [docs](https://github.com/reliverse/rempts).
 
@@ -276,7 +268,7 @@ dler rempts init --cmd my-cmd-1
 dler rempts init --cmds
 ```
 
-### 14. `spell`
+### 13. `spell`
 
 **available spell types:**
 
@@ -334,7 +326,7 @@ await dler.spell({ spells: ["rename-file"], files: [] });
 
 p.s. [see how rse cli uses hooked=true](https://github.com/reliverse/rse/blob/main/src/postbuild.ts)
 
-### 15. `tools`
+### 14. `tools`
 
 lets you run standalone dler features directly from the cli:
 

package/bin/app/rempts/migrate/cmd.js

@@ -0,0 +1,38 @@
+import { defineCommand, defineArgs, confirmPrompt } from "@reliverse/rempts";
+import fs from "fs-extra";
+import { commanderToRempts } from "./impl/commander.js";
+export default defineCommand({
+  args: defineArgs({
+    provider: {
+      type: "string",
+      description: "The provider to migrate from",
+      required: true,
+      allowed: ["commander"]
+    },
+    input: {
+      type: "string",
+      description: "Target directory path containing the files to migrate",
+      required: true
+    }
+  }),
+  async run({ args }) {
+    const { provider, input } = args;
+    const confidence = await confirmPrompt({
+      title: `This is an experimental feature and probably may broke some things.
+It will be improved in the future.
+Are you sure you want to migrate files in ${input}?`,
+      defaultValue: false
+    });
+    if (!confidence) {
+      throw new Error("Migration cancelled");
+    }
+    if (!await fs.pathExists(input)) {
+      throw new Error(`Input directory does not exist: ${input}`);
+    }
+    if (provider === "commander") {
+      await commanderToRempts(input);
+    } else {
+      throw new Error(`Unsupported provider: ${provider}`);
+    }
+  }
+});

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/package.json

@@ -2,7 +2,7 @@
   "dependencies": {
     "@reliverse/relico": "^1.1.2",
     "@reliverse/relinka": "^1.4.5",
-    "@reliverse/rempts": "^1.7.8",
+    "@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.4",
+  "version": "1.2.5",
   "keywords": [
     "reliverse",
     "cli",