@reliverse/dler 1.5.5 → 1.5.6

package/README.md

@@ -295,42 +295,53 @@ dler rempts init --cmds
 **available spell types:**
 
 - `replace-line` — injects contents from one file into another
+- `replace-range` — replaces a range of lines with content from another file
 - `rename-file` — renames the current file
 - `remove-comment` — removes a specific comment from code
 - `remove-line` — removes a specific line from code
 - `remove-file` — deletes the current file
 - `transform-content` — applies a transformation to the file content
+- `transform-line` — applies a transformation to a specific line
 - `copy-file` — copies the current file to a new location
 - `move-file` — moves the current file to a new location
 - `insert-at` — inserts content at a specific position in the file
+- `insert-before` — inserts content before a specific line
+- `insert-after` — inserts content after a specific line
+- `conditional-execute` — executes spells conditionally
 
 **params:**
 
 params are optional and comma-separated.
 
-currently, only the first param is supported:
-
-- `hooked` (boolean, default: `false`)  
-  - `false`: dler handles the spell automatically at postbuild  
+- `hooked` (boolean, default: `true`)  
   - `true`: disables default behavior, so you can trigger the spell yourself (e.g. from your own cli function)
-
-more params coming soon...
+  - `false`: dler handles the spell automatically at postbuild
+- `startLine` (number) — line number to start the operation (for range operations)
+- `endLine` (number) — line number to end the operation (for range operations)
+- `condition` (string) — condition to check before executing the spell
+- `skipIfMissing` (boolean) — whether to skip the spell if the target file doesn't exist
+- `createDir` (boolean) — whether to create the target directory if it doesn't exist
 
 **usage examples:**
 
-- `export * from "../../types.js"; // <dler-replace-line-{hooked=false}>` — injects file contents at this line
-- `// @ts-expect-error <dler-remove-comment-{hooked=false}>` — removes just this comment
-- `// <dler-remove-line-{hooked=false}>` — removes this line
-- `// <dler-remove-file-{hooked=false}>` — deletes this file
-- `// <dler-rename-file-"tsconfig.json"-{hooked=false}>` — renames this file (runs at postbuild because `hooked=false`)
+- `export * from "../../types.js"; // dler-replace-line` — injects file contents at this line (hooked=true by default)
+- `// @ts-expect-error dler-remove-comment` — removes just this comment (hooked=true by default)
+- `// dler-remove-line` — removes this line (hooked=true by default)
+- `// dler-remove-file` — deletes this file (hooked=true by default)
+- `// dler-rename-file-"tsconfig.json"-{hooked=false}` — renames this file (runs at postbuild because `hooked=false`)
+- `// dler-replace-range-"../../types.js"-{startLine=1,endLine=5}` — replaces lines 1-5 with content from types.js
+- `// dler-transform-line-"return line.toUpperCase()"` — transforms the line to uppercase
+- `// dler-insert-before-"import { x } from 'y';"` — inserts import statement before this line
+- `// dler-insert-after-"export { x };"` — inserts export statement after this line
+- `// dler-conditional-execute-{condition="content.includes('TODO')"}` — executes spells only if file contains TODO
 
-**using `hooked=true`:**
+**using `hooked=false`:**
 
-- `// <dler-rename-file-"tsconfig.json"-{hooked=true}>` — renames the file, but only when you trigger it yourself (hooked from your side)
+- `// dler-rename-file-"tsconfig.json"-{hooked=false}` — renames the file immediately at postbuild (not hooked)
 
 **triggering spells:**
 
-from dler’s cli:  
+from dler's cli:  
 
 - `dler spell --trigger rename-file,... --files tsconfig.json,...`
 - `dler spell --trigger all`
@@ -340,10 +351,10 @@ from your own code:
 
 ```ts
 await dler.spell({ spells: ["rename-file"], files: [] });
-// await dler.spell({}) // means all spells and all files
-// spell: ["all"] // means all spells
-// spell: [] // means all spells
-// files: [] // means all files
+await dler.spell({}) // all spells, all files
+spells: ["all"] // means all spells
+spells: [] // also means all spells
+files: [] // means all files
 ```
 
 p.s. [see how rse cli uses hooked=true](https://github.com/reliverse/rse/blob/main/src/postbuild.ts)

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

@@ -0,0 +1,12 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    lib: {
+        type: "string";
+        description: string;
+    };
+    dryRun: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/bin/app/migrate/cmd.js

@@ -0,0 +1,92 @@
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import {
+  migratePatheToPathkit,
+  migratePathkitToPathe
+} from "./codemods/lib-pathe-pathkit.js";
+export default defineCommand({
+  meta: {
+    name: "migrate",
+    version: "1.0.0",
+    description: "Migrate between different libraries and usages"
+  },
+  args: defineArgs({
+    lib: {
+      type: "string",
+      description: "The migration to perform (pathe-to-pathkit | pathkit-to-pathe)"
+    },
+    dryRun: {
+      type: "boolean",
+      description: "Preview changes without applying them",
+      default: false
+    }
+  }),
+  async run({ args }) {
+    let results = [];
+    if (args.lib === "pathe-to-pathkit") {
+      console.log("Migrating from pathe to pathkit...");
+      results = await migratePatheToPathkit(args.dryRun);
+    } else if (args.lib === "pathkit-to-pathe") {
+      console.log("Migrating from pathkit to pathe...");
+      results = await migratePathkitToPathe(args.dryRun);
+    } else {
+      console.error(`Unknown migration: ${args.lib}`);
+      console.log("Available migrations:");
+      console.log("  - pathe-to-pathkit");
+      console.log("  - pathkit-to-pathe");
+      return;
+    }
+    console.log("\nMigration Results:");
+    let successCount = 0;
+    let errorCount = 0;
+    let warningCount = 0;
+    for (const result of results) {
+      const status = result.success ? "\u2713" : "\u2717";
+      console.log(`${status} ${result.file}: ${result.message}`);
+      if (result.changes && result.changes.length > 0) {
+        for (const change of result.changes) {
+          if (change.startsWith("\u26A0\uFE0F")) {
+            console.log(`    ${change}`);
+            warningCount++;
+          } else {
+            console.log(`    - ${change}`);
+          }
+        }
+      }
+      if (result.success) successCount++;
+      else errorCount++;
+    }
+    console.log(
+      `
+Summary: ${successCount} files updated, ${errorCount} errors, ${warningCount} warnings`
+    );
+    if (args.dryRun) {
+      console.log("\nThis was a dry run. No changes were made.");
+      console.log("Run without --dryRun to apply the changes.");
+    } else {
+      console.log("\nMigration completed!");
+      if (args.lib === "pathe-to-pathkit") {
+        console.log("Next steps:");
+        console.log("1. Run 'bun install' to install @reliverse/pathkit");
+        console.log("2. Test your application");
+        console.log(
+          "3. Consider using advanced pathkit features like alias resolution"
+        );
+      } else if (args.lib === "pathkit-to-pathe") {
+        console.log("Next steps:");
+        console.log("1. Run 'bun install' to install pathe");
+        console.log("2. Test your application");
+        if (warningCount > 0) {
+          console.log(
+            "3. \u26A0\uFE0F  Review files with warnings - they may need manual updates"
+          );
+        }
+      } else {
+        console.error(`Unknown migration: ${args.lib}`);
+        console.log("Available migrations:");
+        console.log("  - pathe-to-pathkit");
+        console.log("  - pathkit-to-pathe");
+        return;
+      }
+    }
+  }
+});

package/bin/app/migrate/codemods/lib-pathe-pathkit.d.ts

@@ -0,0 +1,9 @@
+type MigrationResult = {
+    file: string;
+    success: boolean;
+    message: string;
+    changes?: string[];
+};
+export declare function migratePatheToPathkit(dryRun?: boolean): Promise<MigrationResult[]>;
+export declare function migratePathkitToPathe(dryRun?: boolean): Promise<MigrationResult[]>;
+export {};

package/bin/app/migrate/codemods/lib-pathe-pathkit.js

@@ -0,0 +1,258 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile, readdir, stat } from "node:fs/promises";
+import { join, extname } from "node:path";
+async function getAllTsFiles(dir) {
+  const files = [];
+  try {
+    const entries = await readdir(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const stats = await stat(fullPath);
+      if (stats.isDirectory() && !entry.startsWith(".") && entry !== "node_modules") {
+        const subFiles = await getAllTsFiles(fullPath);
+        files.push(...subFiles);
+      } else if (stats.isFile()) {
+        const ext = extname(entry);
+        if ([".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte"].includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+export async function migratePatheToPathkit(dryRun = false) {
+  const results = [];
+  const files = await getAllTsFiles(".");
+  for (const file of files) {
+    try {
+      const content = await readFile(file, "utf-8");
+      let modified = content;
+      const changes = [];
+      const patheImportRegex = /from\s+["']pathe["']/g;
+      if (patheImportRegex.test(content)) {
+        modified = modified.replace(
+          patheImportRegex,
+          'from "@reliverse/pathkit"'
+        );
+        changes.push("Updated pathe imports to @reliverse/pathkit");
+      }
+      const patheUtilsRegex = /from\s+["']pathe\/utils["']/g;
+      if (patheUtilsRegex.test(content)) {
+        modified = modified.replace(
+          patheUtilsRegex,
+          'from "@reliverse/pathkit"'
+        );
+        changes.push("Updated pathe/utils imports to @reliverse/pathkit");
+      }
+      const patheRequireRegex = /require\s*\(\s*["']pathe["']\s*\)/g;
+      if (patheRequireRegex.test(content)) {
+        modified = modified.replace(
+          patheRequireRegex,
+          'require("@reliverse/pathkit")'
+        );
+        changes.push("Updated pathe require to @reliverse/pathkit");
+      }
+      const patheUtilsRequireRegex = /require\s*\(\s*["']pathe\/utils["']\s*\)/g;
+      if (patheUtilsRequireRegex.test(content)) {
+        modified = modified.replace(
+          patheUtilsRequireRegex,
+          'require("@reliverse/pathkit")'
+        );
+        changes.push("Updated pathe/utils require to @reliverse/pathkit");
+      }
+      if (changes.length > 0) {
+        if (!dryRun) {
+          await writeFile(file, modified, "utf-8");
+        }
+        results.push({
+          file,
+          success: true,
+          message: `${changes.length} change(s) made`,
+          changes
+        });
+      }
+    } catch (error) {
+      results.push({
+        file,
+        success: false,
+        message: `Failed to process: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  await updatePackageJson(results, dryRun, {
+    remove: ["pathe"],
+    add: { "@reliverse/pathkit": "^latest" }
+  });
+  return results;
+}
+export async function migratePathkitToPathe(dryRun = false) {
+  const results = [];
+  const files = await getAllTsFiles(".");
+  for (const file of files) {
+    try {
+      const content = await readFile(file, "utf-8");
+      let modified = content;
+      const changes = [];
+      const pathkitImportRegex = /from\s+["']@reliverse\/pathkit["']/g;
+      if (pathkitImportRegex.test(content)) {
+        const advancedFeatures = [
+          "getFileImportsExports",
+          "convertImportPaths",
+          "convertImportExtensionsJsToTs",
+          "normalizeAliases",
+          "resolveAlias",
+          "reverseResolveAlias",
+          "normalizeQuotes"
+        ];
+        const usesAdvancedFeatures = advancedFeatures.some(
+          (feature) => content.includes(feature)
+        );
+        if (usesAdvancedFeatures) {
+          changes.push(
+            "\u26A0\uFE0F  File uses advanced pathkit features - manual review needed"
+          );
+          results.push({
+            file,
+            success: false,
+            message: "Contains advanced pathkit features not available in pathe",
+            changes
+          });
+          continue;
+        }
+        const utilsPattern = /import\s*\{([^}]+)\}\s*from\s*["']@reliverse\/pathkit["']/g;
+        const utilsMatch = utilsPattern.exec(content);
+        if (utilsMatch?.[1]) {
+          const imports = utilsMatch[1].split(",").map((s) => s.trim());
+          const coreImports = imports.filter(
+            (imp) => ![
+              "filename",
+              "normalizeAliases",
+              "resolveAlias",
+              "reverseResolveAlias"
+            ].includes(imp.replace(/\s+as\s+\w+/, ""))
+          );
+          const utilImports = imports.filter(
+            (imp) => [
+              "filename",
+              "normalizeAliases",
+              "resolveAlias",
+              "reverseResolveAlias"
+            ].includes(imp.replace(/\s+as\s+\w+/, ""))
+          );
+          if (coreImports.length > 0 && utilImports.length > 0) {
+            const coreImportStatement = `import { ${coreImports.join(", ")} } from "pathe";`;
+            const utilImportStatement = `import { ${utilImports.join(", ")} } from "pathe/utils";`;
+            modified = modified.replace(
+              utilsMatch[0],
+              `${coreImportStatement}
+${utilImportStatement}`
+            );
+            changes.push(
+              "Split pathkit imports into pathe core and pathe/utils"
+            );
+          } else if (utilImports.length > 0) {
+            modified = modified.replace(
+              pathkitImportRegex,
+              'from "pathe/utils"'
+            );
+            changes.push("Updated pathkit utils imports to pathe/utils");
+          } else {
+            modified = modified.replace(pathkitImportRegex, 'from "pathe"');
+            changes.push("Updated pathkit imports to pathe");
+          }
+        } else {
+          modified = modified.replace(pathkitImportRegex, 'from "pathe"');
+          changes.push("Updated pathkit imports to pathe");
+        }
+      }
+      const pathkitRequireRegex = /require\s*\(\s*["']@reliverse\/pathkit["']\s*\)/g;
+      if (pathkitRequireRegex.test(content)) {
+        modified = modified.replace(pathkitRequireRegex, 'require("pathe")');
+        changes.push("Updated pathkit require to pathe");
+      }
+      if (changes.length > 0) {
+        if (!dryRun) {
+          await writeFile(file, modified, "utf-8");
+        }
+        results.push({
+          file,
+          success: true,
+          message: `${changes.length} change(s) made`,
+          changes
+        });
+      }
+    } catch (error) {
+      results.push({
+        file,
+        success: false,
+        message: `Failed to process: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  await updatePackageJson(results, dryRun, {
+    remove: ["@reliverse/pathkit"],
+    add: { pathe: "^latest" }
+  });
+  return results;
+}
+async function updatePackageJson(results, dryRun, config) {
+  try {
+    const packageJsonPath = "./package.json";
+    if (existsSync(packageJsonPath)) {
+      const packageContent = await readFile(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageContent);
+      let packageChanged = false;
+      const packageChanges = [];
+      for (const pkg of config.remove) {
+        if (packageJson.dependencies?.[pkg]) {
+          packageJson.dependencies = Object.fromEntries(
+            Object.entries(packageJson.dependencies).filter(
+              ([key]) => key !== pkg
+            )
+          );
+          packageChanged = true;
+          packageChanges.push(`Removed ${pkg} from dependencies`);
+        }
+        if (packageJson.devDependencies?.[pkg]) {
+          packageJson.devDependencies = Object.fromEntries(
+            Object.entries(packageJson.devDependencies).filter(
+              ([key]) => key !== pkg
+            )
+          );
+          packageChanged = true;
+          packageChanges.push(`Removed ${pkg} from devDependencies`);
+        }
+      }
+      for (const [pkg, version] of Object.entries(config.add)) {
+        if (packageChanged && !packageJson.dependencies?.[pkg]) {
+          if (!packageJson.dependencies) packageJson.dependencies = {};
+          packageJson.dependencies[pkg] = version;
+          packageChanges.push(`Added ${pkg} to dependencies`);
+        }
+      }
+      if (packageChanged) {
+        if (!dryRun) {
+          await writeFile(
+            packageJsonPath,
+            JSON.stringify(packageJson, null, 2) + "\n",
+            "utf-8"
+          );
+        }
+        results.push({
+          file: packageJsonPath,
+          success: true,
+          message: `${packageChanges.length} change(s) made`,
+          changes: packageChanges
+        });
+      }
+    }
+  } catch (error) {
+    results.push({
+      file: "./package.json",
+      success: false,
+      message: `Failed to update package.json: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+}

package/bin/app/migrate/codemods/ts-module-resolution.d.ts

@@ -0,0 +1,10 @@
+type MigrationResult = {
+    file: string;
+    success: boolean;
+    message: string;
+    changes?: string[];
+};
+export declare function migrateToNodeNext(dryRun?: boolean): Promise<MigrationResult[]>;
+export declare function migrateToBundler(dryRun?: boolean): Promise<MigrationResult[]>;
+export declare function migrateModuleResolution(target: "nodenext" | "bundler", dryRun?: boolean): Promise<MigrationResult[]>;
+export {};

package/bin/app/migrate/codemods/ts-module-resolution.js

@@ -0,0 +1,231 @@
+import { getFileImportsExports } from "@reliverse/pathkit";
+import { existsSync } from "node:fs";
+import { readFile, writeFile, readdir, stat } from "node:fs/promises";
+import { join, extname } from "node:path";
+async function getAllTsFiles(dir) {
+  const files = [];
+  try {
+    const entries = await readdir(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const stats = await stat(fullPath);
+      if (stats.isDirectory() && !entry.startsWith(".") && entry !== "node_modules") {
+        const subFiles = await getAllTsFiles(fullPath);
+        files.push(...subFiles);
+      } else if (stats.isFile()) {
+        const ext = extname(entry);
+        if ([".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"].includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+async function updateTsConfig(targetResolution, dryRun = false) {
+  const results = [];
+  const tsConfigPath = "./tsconfig.json";
+  if (!existsSync(tsConfigPath)) {
+    results.push({
+      file: tsConfigPath,
+      success: false,
+      message: "tsconfig.json not found"
+    });
+    return results;
+  }
+  try {
+    const content = await readFile(tsConfigPath, "utf-8");
+    const tsConfig = JSON.parse(content);
+    const changes = [];
+    if (!tsConfig.compilerOptions) {
+      tsConfig.compilerOptions = {};
+    }
+    if (tsConfig.compilerOptions.moduleResolution !== targetResolution) {
+      tsConfig.compilerOptions.moduleResolution = targetResolution;
+      changes.push(`Set moduleResolution to ${targetResolution}`);
+    }
+    if (targetResolution === "nodenext") {
+      if (tsConfig.compilerOptions.module !== "nodenext") {
+        tsConfig.compilerOptions.module = "nodenext";
+        changes.push("Set module to nodenext");
+      }
+    } else if (targetResolution === "bundler") {
+      if (tsConfig.compilerOptions.module !== "preserve") {
+        tsConfig.compilerOptions.module = "preserve";
+        changes.push("Set module to preserve");
+      }
+      if (!tsConfig.compilerOptions.noEmit) {
+        tsConfig.compilerOptions.noEmit = true;
+        changes.push("Enabled noEmit");
+      }
+    }
+    if (!tsConfig.compilerOptions.target) {
+      tsConfig.compilerOptions.target = "ES2022";
+      changes.push("Set target to ES2022");
+    }
+    if (changes.length > 0) {
+      if (!dryRun) {
+        await writeFile(
+          tsConfigPath,
+          JSON.stringify(tsConfig, null, 2) + "\n",
+          "utf-8"
+        );
+      }
+      results.push({
+        file: tsConfigPath,
+        success: true,
+        message: `${changes.length} change(s) made`,
+        changes
+      });
+    } else {
+      results.push({
+        file: tsConfigPath,
+        success: true,
+        message: "Already configured correctly"
+      });
+    }
+  } catch (error) {
+    results.push({
+      file: tsConfigPath,
+      success: false,
+      message: `Failed to update: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  return results;
+}
+async function updatePackageJson(dryRun = false) {
+  const results = [];
+  const packageJsonPath = "./package.json";
+  if (!existsSync(packageJsonPath)) {
+    results.push({
+      file: packageJsonPath,
+      success: false,
+      message: "package.json not found"
+    });
+    return results;
+  }
+  try {
+    const content = await readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    const changes = [];
+    if (packageJson.type !== "module") {
+      packageJson.type = "module";
+      changes.push('Set type to "module"');
+    }
+    if (changes.length > 0) {
+      if (!dryRun) {
+        await writeFile(
+          packageJsonPath,
+          JSON.stringify(packageJson, null, 2) + "\n",
+          "utf-8"
+        );
+      }
+      results.push({
+        file: packageJsonPath,
+        success: true,
+        message: `${changes.length} change(s) made`,
+        changes
+      });
+    } else {
+      results.push({
+        file: packageJsonPath,
+        success: true,
+        message: "Already configured correctly"
+      });
+    }
+  } catch (error) {
+    results.push({
+      file: packageJsonPath,
+      success: false,
+      message: `Failed to update: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  return results;
+}
+async function updateImportExtensions(targetResolution, dryRun = false) {
+  const results = [];
+  const files = await getAllTsFiles(".");
+  for (const file of files) {
+    try {
+      const content = await readFile(file, "utf-8");
+      const analysis = getFileImportsExports(content, {
+        kind: "import",
+        pathTypes: ["relative", "absolute"]
+      });
+      if (analysis.length === 0) continue;
+      let modified = content;
+      const changes = [];
+      let hasChanges = false;
+      for (const imp of analysis) {
+        if (!imp.source) continue;
+        const isRelativeOrAbsolute = imp.pathType === "relative" || imp.pathType === "absolute";
+        if (!isRelativeOrAbsolute) continue;
+        if (targetResolution === "nodenext") {
+          if (imp.source.endsWith(".ts") || imp.source.endsWith(".tsx")) {
+            const newSource = imp.source.replace(/\.tsx?$/, ".js");
+            modified = modified.replace(`"${imp.source}"`, `"${newSource}"`).replace(`'${imp.source}'`, `'${newSource}'`);
+            changes.push(`${imp.source} \u2192 ${newSource}`);
+            hasChanges = true;
+          } else if (!imp.source.includes(".") && !imp.source.endsWith("/")) {
+            const newSource = `${imp.source}.js`;
+            modified = modified.replace(`"${imp.source}"`, `"${newSource}"`).replace(`'${imp.source}'`, `'${newSource}'`);
+            changes.push(`${imp.source} \u2192 ${newSource}`);
+            hasChanges = true;
+          }
+        } else if (targetResolution === "bundler") {
+          if (imp.source.match(/\.(js|jsx|ts|tsx)$/)) {
+            const newSource = imp.source.replace(/\.(js|jsx|ts|tsx)$/, "");
+            modified = modified.replace(`"${imp.source}"`, `"${newSource}"`).replace(`'${imp.source}'`, `'${newSource}'`);
+            changes.push(`${imp.source} \u2192 ${newSource}`);
+            hasChanges = true;
+          }
+        }
+      }
+      if (hasChanges) {
+        if (!dryRun) {
+          await writeFile(file, modified, "utf-8");
+        }
+        results.push({
+          file,
+          success: true,
+          message: `${changes.length} import(s) updated`,
+          changes
+        });
+      }
+    } catch (error) {
+      results.push({
+        file,
+        success: false,
+        message: `Failed to process: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  return results;
+}
+export async function migrateToNodeNext(dryRun = false) {
+  const results = [];
+  const tsConfigResults = await updateTsConfig("nodenext", dryRun);
+  results.push(...tsConfigResults);
+  const packageResults = await updatePackageJson(dryRun);
+  results.push(...packageResults);
+  const importResults = await updateImportExtensions("nodenext", dryRun);
+  results.push(...importResults);
+  return results;
+}
+export async function migrateToBundler(dryRun = false) {
+  const results = [];
+  const tsConfigResults = await updateTsConfig("bundler", dryRun);
+  results.push(...tsConfigResults);
+  const packageResults = await updatePackageJson(dryRun);
+  results.push(...packageResults);
+  const importResults = await updateImportExtensions("bundler", dryRun);
+  results.push(...importResults);
+  return results;
+}
+export async function migrateModuleResolution(target, dryRun = false) {
+  if (target === "nodenext") {
+    return migrateToNodeNext(dryRun);
+  }
+  return migrateToBundler(dryRun);
+}

package/bin/app/relifso/rename/cmd.js

@@ -64,7 +64,6 @@ async function prepareCLIFiles(revert = false, recursive = true, useDtsTxtForPre
     const fileName = basename(file);
     const baseName = basename(file, ext);
     const dir = dirname(fullPath);
-    relinka("log", `Processing file: ${fullPath}`);
     if (revert) {
       if (file.endsWith(".json.json")) {
         const originalName = join(dir, fileName.replace(".json.json", ".json"));

package/bin/init/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.5.5";
+const version = "1.5.6";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/bin/libs/sdk/sdk-impl/spell/spell-executors.d.ts

@@ -8,3 +8,8 @@ export declare const copyFileExecutor: (spell: Spell, filePath: string) => Promi
 export declare const moveFileExecutor: (spell: Spell, filePath: string) => Promise<SpellResult>;
 export declare const transformContentExecutor: (spell: Spell, filePath: string, content: string) => Promise<SpellResult>;
 export declare const insertAtExecutor: (spell: Spell, filePath: string, content: string) => Promise<SpellResult>;
+export declare const replaceRangeExecutor: (spell: Spell, filePath: string, content: string) => Promise<SpellResult>;
+export declare const transformLineExecutor: (spell: Spell, filePath: string, content: string) => Promise<SpellResult>;
+export declare const insertBeforeExecutor: (spell: Spell, filePath: string, content: string) => Promise<SpellResult>;
+export declare const insertAfterExecutor: (spell: Spell, filePath: string, content: string) => Promise<SpellResult>;
+export declare const conditionalExecuteExecutor: (spell: Spell, filePath: string, content: string) => Promise<SpellResult>;

package/bin/libs/sdk/sdk-impl/spell/spell-executors.js

@@ -1,5 +1,6 @@
 import path from "@reliverse/pathkit";
 import * as fs from "./spell-filesystem.js";
+import { executeSpell } from "./spell-mod.js";
 export const replaceLineExecutor = async (spell, filePath, content) => {
   if (!spell.lineNumber) {
     return {
@@ -235,6 +236,38 @@ export const transformContentExecutor = async (spell, filePath, content) => {
           }
         );
         break;
+      case "update-dependencies":
+        if (filePath.endsWith("package.json")) {
+          const pkg = JSON.parse(content);
+          let newDeps = { ...pkg.dependencies };
+          if (newDeps.pathe) {
+            const { ...rest } = newDeps;
+            newDeps = rest;
+          }
+          let newDevDeps = { ...pkg.devDependencies };
+          if (newDevDeps.pathe) {
+            const { ...rest } = newDevDeps;
+            newDevDeps = rest;
+          }
+          newDeps["@reliverse/pathkit"] = "latest";
+          const newPkg = {
+            ...pkg,
+            dependencies: newDeps,
+            devDependencies: newDevDeps
+          };
+          newContent = JSON.stringify(newPkg, null, 2);
+        } else {
+          return {
+            spell,
+            file: filePath,
+            success: false,
+            message: "update-dependencies can only be used on package.json"
+          };
+        }
+        break;
+      case "update-imports":
+        newContent = content.replace(/from\s+['"]pathe['"]/g, 'from "@reliverse/pathkit"').replace(/from\s+['"]@unjs\/pathe['"]/g, 'from "@reliverse/pathkit"');
+        break;
       default:
         return {
           spell,
@@ -305,3 +338,257 @@ export const insertAtExecutor = async (spell, filePath, content) => {
     };
   }
 };
+export const replaceRangeExecutor = async (spell, filePath, content) => {
+  if (!spell.lineNumber || !spell.params.startLine || !spell.params.endLine) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Line numbers not provided"
+    };
+  }
+  if (!spell.value) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Target file not specified"
+    };
+  }
+  const includeFilePath = path.resolve(path.dirname(filePath), spell.value);
+  try {
+    const includeContent = await fs.readFile(includeFilePath);
+    const lines = content.split("\n");
+    const start = spell.params.startLine - 1;
+    const end = spell.params.endLine;
+    const originalLines = lines.slice(start, end);
+    lines.splice(start, end - start, ...includeContent.trim().split("\n"));
+    const newContent = lines.join("\n");
+    await fs.writeFile(filePath, newContent);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: `Lines ${spell.params.startLine}-${spell.params.endLine} replaced with content from ${includeFilePath}`,
+      changes: {
+        before: originalLines.join("\n"),
+        after: includeContent.trim()
+      },
+      details: {
+        linesAffected: Array.from(
+          { length: end - start },
+          (_, i) => start + i + 1
+        )
+      }
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to replace range: ${error}`
+    };
+  }
+};
+export const transformLineExecutor = async (spell, filePath, content) => {
+  if (!spell.lineNumber) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Line number not provided"
+    };
+  }
+  if (!spell.value) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Transformation not specified"
+    };
+  }
+  try {
+    const lines = content.split("\n");
+    const originalLine = lines[spell.lineNumber - 1];
+    const transformCode = spell.value;
+    const transformFn = new Function("line", transformCode);
+    const transformedLine = transformFn(originalLine);
+    lines[spell.lineNumber - 1] = transformedLine;
+    const newContent = lines.join("\n");
+    await fs.writeFile(filePath, newContent);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: "Line transformed",
+      changes: {
+        before: originalLine ?? "",
+        after: transformedLine
+      },
+      details: {
+        linesAffected: [spell.lineNumber]
+      }
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to transform line: ${error}`
+    };
+  }
+};
+export const insertBeforeExecutor = async (spell, filePath, content) => {
+  if (!spell.lineNumber) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Line number not provided"
+    };
+  }
+  if (!spell.value) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Content to insert not specified"
+    };
+  }
+  try {
+    const lines = content.split("\n");
+    const insertContent = spell.value.split("\n");
+    const lineNumber = spell.lineNumber;
+    lines.splice(lineNumber - 1, 0, ...insertContent);
+    const newContent = lines.join("\n");
+    await fs.writeFile(filePath, newContent);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: "Content inserted before line",
+      changes: {
+        before: "",
+        after: insertContent.join("\n")
+      },
+      details: {
+        linesAffected: Array.from(
+          { length: insertContent.length },
+          (_, i) => lineNumber + i
+        )
+      }
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to insert content: ${error}`
+    };
+  }
+};
+export const insertAfterExecutor = async (spell, filePath, content) => {
+  if (!spell.lineNumber) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Line number not provided"
+    };
+  }
+  if (!spell.value) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Content to insert not specified"
+    };
+  }
+  try {
+    const lines = content.split("\n");
+    const insertContent = spell.value.split("\n");
+    const lineNumber = spell.lineNumber;
+    lines.splice(lineNumber, 0, ...insertContent);
+    const newContent = lines.join("\n");
+    await fs.writeFile(filePath, newContent);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: "Content inserted after line",
+      changes: {
+        before: "",
+        after: insertContent.join("\n")
+      },
+      details: {
+        linesAffected: Array.from(
+          { length: insertContent.length },
+          (_, i) => lineNumber + i + 1
+        )
+      }
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to insert content: ${error}`
+    };
+  }
+};
+export const conditionalExecuteExecutor = async (spell, filePath, content) => {
+  if (!spell.params.condition) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Condition not provided"
+    };
+  }
+  try {
+    const conditionFn = new Function(
+      "content",
+      "filePath",
+      spell.params.condition
+    );
+    const shouldExecute = conditionFn(content, filePath);
+    if (!shouldExecute) {
+      return {
+        spell,
+        file: filePath,
+        success: true,
+        message: "Condition not met, skipping execution"
+      };
+    }
+    if (!spell.dependsOn?.length) {
+      return {
+        spell,
+        file: filePath,
+        success: false,
+        message: "No dependent spells specified"
+      };
+    }
+    const results = [];
+    for (const dependentSpell of spell.dependsOn) {
+      const result = await executeSpell(dependentSpell, filePath, content);
+      results.push(result);
+    }
+    const allSuccessful = results.every((r) => r.success);
+    return {
+      spell,
+      file: filePath,
+      success: allSuccessful,
+      message: allSuccessful ? "All dependent spells executed successfully" : "Some dependent spells failed",
+      details: {
+        filesAffected: results.map((r) => r.file)
+      }
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to execute condition: ${error}`
+    };
+  }
+};

package/bin/libs/sdk/sdk-impl/spell/spell-parser.js

@@ -1,7 +1,7 @@
-const SPELL_REGEX = /<dler-([a-z-]+)-(?:"([^"]+)")?-?(?:{([^}]+)})?>/;
+const SPELL_REGEX = /dler-([a-z-]+)-(?:"([^"]+)")?-?(?:{([^}]+)})?/;
 export const parseParams = (paramsStr) => {
   const defaultParams = {
-    hooked: false
+    hooked: true
   };
   if (!paramsStr) return defaultParams;
   const params = { ...defaultParams };

package/bin/libs/sdk/sdk-impl/spell/spell-types.d.ts

@@ -1,6 +1,18 @@
-export type SpellType = "replace-line" | "rename-file" | "remove-comment" | "remove-line" | "remove-file" | "transform-content" | "copy-file" | "move-file" | "insert-at";
+export type SpellType = "replace-line" | "replace-range" | "rename-file" | "remove-comment" | "remove-line" | "remove-file" | "transform-content" | "transform-line" | "copy-file" | "move-file" | "insert-at" | "insert-before" | "insert-after" | "conditional-execute";
 export type SpellParams = {
+    /** Whether the spell should be executed manually (true) or automatically at postbuild (false) */
     hooked: boolean;
+    /** Line number to start the operation (for range operations) */
+    startLine?: number;
+    /** Line number to end the operation (for range operations) */
+    endLine?: number;
+    /** Condition to check before executing the spell */
+    condition?: string;
+    /** Whether to skip the spell if the target file doesn't exist */
+    skipIfMissing?: boolean;
+    /** Whether to create the target directory if it doesn't exist */
+    createDir?: boolean;
+    /** Custom parameters for specific spell types */
     [key: string]: any;
 };
 export type Spell = {
@@ -10,17 +22,25 @@ export type Spell = {
     lineNumber?: number;
     fullMatch?: string;
     fileName?: string;
+    /** Optional array of spells that must be executed before this one */
+    dependsOn?: Spell[];
 };
 export type SpellExecutionOptions = {
     spells?: (SpellType | "all")[];
     files?: string[];
     dryRun?: boolean;
+    /** Whether to show detailed changes in the output */
+    showChanges?: boolean;
+    /** Whether to validate spell parameters before execution */
+    validate?: boolean;
 };
 export type FileOperation = {
     type: "read" | "write" | "rename" | "remove" | "copy" | "move";
     sourcePath: string;
     targetPath?: string;
     content?: string;
+    /** Whether to create parent directories if they don't exist */
+    createDir?: boolean;
 };
 export type SpellResult = {
     spell: Spell;
@@ -31,4 +51,10 @@ export type SpellResult = {
         before: string;
         after: string;
     };
+    /** Detailed information about the changes made */
+    details?: {
+        linesAffected?: number[];
+        filesAffected?: string[];
+        validationErrors?: string[];
+    };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
     "@reliverse/bleump": "^1.1.4",
-    "@reliverse/pathkit": "^1.1.5",
+    "@reliverse/pathkit": "^1.1.6",
     "@reliverse/reglob": "^1.0.0",
     "@reliverse/relico": "^1.1.2",
     "@reliverse/relifso": "^1.3.0",
@@ -41,7 +41,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.5.5",
+  "version": "1.5.6",
   "keywords": [
     "reliverse",
     "cli",