@reliverse/dler 1.7.86 → 1.7.88

package/README.md

@@ -2,7 +2,7 @@
 
 [sponsor](https://github.com/sponsors/blefnk) — [discord](https://discord.gg/pb8ukbwpsj) — [github](https://github.com/reliverse/dler) — [npm](https://npmjs.com/@reliverse/dler)
 
-> @reliverse/dler (formerly relidler; `/ˈdiː.lər/`, dealer) is a unified package manager for typescript/javascript projects.
+> @reliverse/dler (formerly relidler; `/ˈdiː.lər/`, dealer) is both a unified package manager for typescript/javascript projects and a flexible framework for creating, building, and publishing js/ts libraries to npm and jsr.
 >
 > dler is your package manager’s best friend — it extends bun, deno (🔜), pnpm, yarn, and npm with powerful and modern features.
 >

package/bin/app/build/postbuild.js

@@ -31,7 +31,7 @@ export async function dlerPostBuild(isDev, debugDontCopyNonBuildFiles) {
     const tools = createPostBuildToolRunner();
     const availableTools = config.runAfterBuild.filter((toolName) => toolName in tools).map((toolName) => ({ toolName, ...tools[toolName] }));
     for (const { name, run } of availableTools) {
-      relinka("log", `Running ${name}...`);
+      relinka("verbose", `Running ${name}...`);
       await run();
     }
   }

package/bin/app/build/ppb-utils.js

@@ -86,7 +86,7 @@ export async function directoryExists(dirPath) {
 }
 export async function executeDlerHooks(hooks, phase) {
   if (!hooks.length) return;
-  relinka("log", `[dlerPreBuild] Running ${phase} hooks...`);
+  relinka("verbose", `[dlerPreBuild] Running ${phase} hooks...`);
   for (const hook of hooks) {
     try {
       await hook();

package/bin/app/build/prebuild.js

@@ -105,7 +105,7 @@ export async function dlerPreBuild(config) {
   );
   const commandsToRun = availableTools.filter(Boolean);
   for (const { name, run } of commandsToRun) {
-    relinka("log", `Running ${name}...`);
+    relinka("verbose", `Running ${name}...`);
     await run();
   }
 }

package/bin/app/catalog/cmd.js

@@ -41,7 +41,7 @@ export default defineCommand({
         break;
       default:
         relinka("error", `Unknown action: ${action}`);
-        relinka("log", "Available actions: list, ls");
+        relinka("verbose", "Available actions: list, ls");
         return process.exit(1);
     }
   }

package/bin/app/create/cmd.js

@@ -77,7 +77,7 @@ async function handleFileCreation({
       options: possibleTypes.map((pt) => ({ label: pt, value: pt }))
     });
     if (chosen.length === 0) {
-      relinka("log", "No file types selected. Exiting...");
+      relinka("verbose", "No file types selected. Exiting...");
       return;
     }
     const requests = chosen.map((ct) => ({
@@ -113,8 +113,8 @@ async function handleTemplateCreation({
 }) {
   if (!template) {
     relinka.error("Template name is required for template creation");
-    relinka.log("Usage: dler create <template-name>");
-    relinka.log("Example: dler create react-app");
+    relinka.verbose("Usage: dler create <template-name>");
+    relinka.verbose("Example: dler create react-app");
     return process.exit(1);
   }
   try {
@@ -145,8 +145,8 @@ async function handleTemplateCreation({
     if (destDir !== ".") {
       createCommand.push(destDir);
     }
-    relinka.log(`Creating project from template: ${template}`);
-    relinka.log(`Using command: ${createCommand.join(" ")}`);
+    relinka.verbose(`Creating project from template: ${template}`);
+    relinka.verbose(`Using command: ${createCommand.join(" ")}`);
     const result = x(createCommand[0], createCommand.slice(1), {
       nodeOptions: {
         cwd: workingDir,

package/bin/app/fs/cmd.js

@@ -145,7 +145,7 @@ export default defineCommand({
               return;
             }
             await fs.remove(resolvedPath);
-            relinka("log", `Removed: ${resolvedPath}`);
+            relinka("verbose", `Removed: ${resolvedPath}`);
             removedCount++;
           } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -155,7 +155,7 @@ export default defineCommand({
         { concurrency: concurrency2 }
       );
       if (removedCount > 0) {
-        relinka("log", `Successfully removed ${removedCount} item(s) matching: ${target}`);
+        relinka("verbose", `Successfully removed ${removedCount} item(s) matching: ${target}`);
       } else {
         relinka("warn", `No items were removed for pattern: ${target}`);
       }
@@ -208,7 +208,7 @@ export default defineCommand({
             ]
           });
           if (confirm === "no") {
-            relinka("log", "Operation cancelled by user");
+            relinka("verbose", "Operation cancelled by user");
             return;
           }
         }
@@ -256,7 +256,7 @@ export default defineCommand({
               throw new Error(`Destination file already exists: ${destPath}`);
             }
             await fs.copyFile(file, destPath);
-            relinka("log", `Copied '${file}' to '${destPath}'`);
+            relinka("verbose", `Copied '${file}' to '${destPath}'`);
           },
           { concurrency, stopOnError: true }
         );
@@ -274,7 +274,7 @@ export default defineCommand({
       if (prepareMyCLI === true) {
         try {
           await prepareCLIFiles(revert === true, recursive, useDtsTxtForPrepareMyCLI);
-          relinka("log", "Successfully prepared CLI files");
+          relinka("verbose", "Successfully prepared CLI files");
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
           relinka("error", `Error preparing CLI: ${errorMessage}`);
@@ -291,7 +291,7 @@ export default defineCommand({
       }
       try {
         await safeRename(source, destination);
-        relinka("log", `Successfully renamed '${source}' to '${destination}'`);
+        relinka("verbose", `Successfully renamed '${source}' to '${destination}'`);
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         relinka("error", `Error renaming: ${errorMessage}`);

package/bin/app/init/cmd.js

@@ -7,7 +7,7 @@ export default defineCommand({
     description: "Initialize a new project"
   },
   async run() {
-    relinka.info(
+    relinka.verbose(
       "Command not implemented yet. For now, please install `@reliverse/rse` and run `rse cli`."
     );
   }

package/bin/app/install/cmd.js

@@ -121,7 +121,7 @@ export default defineCommand({
           await (name ? addDependency(name, options) : installDependencies(options));
         } else {
           relinka.error(`Unknown action: ${action}`);
-          relinka.log("Available actions: install, add, i, dedupe");
+          relinka.verbose("Available actions: install, add, i, dedupe");
           return process.exit(1);
         }
       }

package/bin/app/libs/cmd.js

@@ -82,7 +82,7 @@ export default defineCommand({
       const mainFilePath = path.join(libsDirSrc, libMainFile);
       if (!await fs.pathExists(libDirPath)) {
         await fs.ensureDir(libDirPath);
-        relinka("log", `\u2705 Created library directory: ${libDirPath}`);
+        relinka("verbose", `\u2705 Created library directory: ${libDirPath}`);
       }
       if (!await fs.pathExists(mainFilePath) || args.overwrite) {
         const mainFileContent = `// Main entry point for ${libName}
@@ -90,7 +90,7 @@ export default defineCommand({
   `;
         await fs.ensureDir(path.dirname(mainFilePath));
         await fs.writeFile(mainFilePath, mainFileContent, "utf8");
-        relinka("log", `\u2705 Created/Updated main file: ${mainFilePath}`);
+        relinka("verbose", `\u2705 Created/Updated main file: ${mainFilePath}`);
       } else {
         relinka("warn", `\u26A0\uFE0F Main file already exists: ${mainFilePath}. Use --overwrite to update.`);
       }

package/bin/app/merge/cmd.js

@@ -342,8 +342,8 @@ export default defineCommand({
       const verbose = args.verbose ?? false;
       const force = args.force ?? true;
       if (verbose) {
-        relinka("log", "Verbose logging enabled");
-        relinka("log", `Force mode: ${force ? "enabled" : "disabled"}`);
+        relinka("verbose", "Verbose logging enabled");
+        relinka("verbose", `Force mode: ${force ? "enabled" : "disabled"}`);
       }
       let include = args.s ?? [];
       if (include.length === 0) {

package/bin/app/migrate/cmd.js

@@ -67,45 +67,45 @@ Are you sure you want to migrate files in ${args.project}?`,
       }
     }
     if (args.codemod === "anything-bun") {
-      relinka("log", "Migrating to Bun...");
+      relinka("verbose", "Migrating to Bun...");
       await migrateAnythingToBun({
         project: args.project,
         dryRun: args.dryRun,
         noBackup: args.noBackup
       });
       if (!args.dryRun) {
-        relinka("log", "\nMigration completed!");
-        relinka("log", "Next steps:");
-        relinka("log", "1. Run 'bun install' to install dependencies with Bun");
-        relinka("log", "2. Test your application thoroughly");
-        relinka("log", "3. Review async/await usage in converted file operations");
-        relinka("log", "4. Update any custom database queries to use Bun.sql syntax");
-        relinka("log", "5. Review and update any custom middleware in Express apps");
+        relinka("verbose", "\nMigration completed!");
+        relinka("verbose", "Next steps:");
+        relinka("verbose", "1. Run 'bun install' to install dependencies with Bun");
+        relinka("verbose", "2. Test your application thoroughly");
+        relinka("verbose", "3. Review async/await usage in converted file operations");
+        relinka("verbose", "4. Update any custom database queries to use Bun.sql syntax");
+        relinka("verbose", "5. Review and update any custom middleware in Express apps");
       }
       return;
     }
     let results = [];
     if (args.codemod === "path-pathkit") {
-      relinka("log", "Migrating from node:path and/or pathe to @reliverse/pathkit...");
+      relinka("verbose", "Migrating from node:path and/or pathe to @reliverse/pathkit...");
       results = await migratePathToPathkit(args.dryRun);
     } else if (args.codemod === "fs-relifso") {
-      relinka("log", "Migrating from node:fs and/or fs-extra to @reliverse/relifso...");
+      relinka("verbose", "Migrating from node:fs and/or fs-extra to @reliverse/relifso...");
       results = await migrateFsToRelifso(args.dryRun);
     } else if (args.codemod === "nodenext-bundler") {
       if (!["nodenext", "bundler"].includes(args.mrTarget)) {
         relinka("error", `Invalid mrTarget: ${args.mrTarget}`);
-        relinka("log", "Available targets:");
-        relinka("log", "  - nodenext");
-        relinka("log", "  - bundler");
+        relinka("verbose", "Available targets:");
+        relinka("verbose", "  - nodenext");
+        relinka("verbose", "  - bundler");
         return;
       }
-      relinka("log", `Migrating to ${args.mrTarget} module resolution...`);
+      relinka("verbose", `Migrating to ${args.mrTarget} module resolution...`);
       results = await migrateModuleResolution(args.mrTarget, args.dryRun);
     } else if (args.codemod === "readdir-glob") {
-      relinka("log", "Migrating from fs.readdir to globby...");
+      relinka("verbose", "Migrating from fs.readdir to globby...");
       results = await migrateReaddirToGlob(args.dryRun);
     } else if (args.codemod === "console-relinka") {
-      relinka("log", "Migrating logging format...");
+      relinka("verbose", "Migrating logging format...");
       await consoleToRelinka(
         args.consoleRelinkaInput,
         args.consoleRelinkaFrom,
@@ -114,13 +114,13 @@ Are you sure you want to migrate files in ${args.project}?`,
       return;
     } else {
       relinka("error", `Unknown migration: ${args.codemod}`);
-      relinka("log", "Available migrations:");
-      relinka("log", "  - anything-bun");
-      relinka("log", "  - path-pathkit");
-      relinka("log", "  - fs-relifso");
-      relinka("log", "  - nodenext-bundler");
-      relinka("log", "  - readdir-glob");
-      relinka("log", "  - console-relinka");
+      relinka("verbose", "Available migrations:");
+      relinka("verbose", "  - anything-bun");
+      relinka("verbose", "  - path-pathkit");
+      relinka("verbose", "  - fs-relifso");
+      relinka("verbose", "  - nodenext-bundler");
+      relinka("verbose", "  - readdir-glob");
+      relinka("verbose", "  - console-relinka");
       return;
     }
     relinka("info", "\nMigration Results:");
@@ -129,14 +129,14 @@ Are you sure you want to migrate files in ${args.project}?`,
     let warningCount = 0;
     for (const result of results) {
       const status = result.success ? "\u2713" : "\u2717";
-      relinka("log", `${status} ${result.file}: ${result.message}`);
+      relinka("verbose", `${status} ${result.file}: ${result.message}`);
       if (result.changes && result.changes.length > 0) {
         for (const change of result.changes) {
           if (change.startsWith("\u26A0\uFE0F")) {
-            relinka("log", `    ${change}`);
+            relinka("verbose", `    ${change}`);
             warningCount++;
           } else {
-            relinka("log", `    - ${change}`);
+            relinka("verbose", `    - ${change}`);
           }
         }
       }
@@ -150,35 +150,38 @@ Summary: ${successCount} files updated, ${errorCount} errors, ${warningCount} wa
     );
     if (args.dryRun) {
       relinka("info", "\nThis was a dry run. No changes were made.");
-      relinka("log", "Run without --dryRun to apply the changes.");
+      relinka("verbose", "Run without --dryRun to apply the changes.");
     } else {
       relinka("success", "\nMigration completed!");
       if (args.codemod === "path-pathkit") {
-        relinka("log", "Next steps:");
-        relinka("log", "1. Run 'bun install' to install @reliverse/pathkit");
-        relinka("log", "2. Test your application");
-        relinka("log", "3. Tip: Consider using advanced pathkit features like alias resolution");
+        relinka("verbose", "Next steps:");
+        relinka("verbose", "1. Run 'bun install' to install @reliverse/pathkit");
+        relinka("verbose", "2. Test your application");
+        relinka(
+          "verbose",
+          "3. Tip: Consider using advanced pathkit features like alias resolution"
+        );
       } else if (args.codemod === "fs-relifso") {
-        relinka("log", "Next steps:");
-        relinka("log", "1. Run 'bun install' to install @reliverse/relifso");
-        relinka("log", "2. Test your application");
-        relinka("log", "3. Review any file system operations that might need manual updates");
+        relinka("verbose", "Next steps:");
+        relinka("verbose", "1. Run 'bun install' to install @reliverse/relifso");
+        relinka("verbose", "2. Test your application");
+        relinka("verbose", "3. Review any file system operations that might need manual updates");
       } else if (args.codemod === "nodenext-bundler") {
-        relinka("log", "Next steps:");
-        relinka("log", "1. Test your application");
+        relinka("verbose", "Next steps:");
+        relinka("verbose", "1. Test your application");
         if (args.mrTarget === "nodenext") {
-          relinka("log", "2. Ensure your build tools support .js extensions in imports");
+          relinka("verbose", "2. Ensure your build tools support .js extensions in imports");
         } else if (args.mrTarget === "bundler") {
-          relinka("log", "2. Ensure your bundler is configured correctly");
+          relinka("verbose", "2. Ensure your bundler is configured correctly");
         }
         if (warningCount > 0) {
           relinka("warn", "3. \u26A0\uFE0F  Review files with warnings - they may need manual updates");
         }
       } else if (args.codemod === "readdir-glob") {
-        relinka("log", "Next steps:");
-        relinka("log", "1. Run 'bun install' to install globby");
-        relinka("log", "2. Test your application");
-        relinka("log", "3. Review any file system operations that might need manual updates");
+        relinka("verbose", "Next steps:");
+        relinka("verbose", "1. Run 'bun install' to install globby");
+        relinka("verbose", "2. Test your application");
+        relinka("verbose", "3. Review any file system operations that might need manual updates");
       }
     }
   }

package/bin/app/migrate/codemods/anything-bun.js

@@ -316,7 +316,7 @@ const server = serve({
     return new Response("Not Found", { status: 404 });
   },
 });
-relinka("log", \`Server running on localhost:\${server.port}\`);
+relinka("verbose", \`Server running on localhost:\${server.port}\`);
 `;
     if (content.includes("const app = express()")) {
       transformedContent = transformedContent.replace(
@@ -424,22 +424,22 @@ const createBackup = async (projectRoot) => {
 };
 const writeTransformedFile = async (projectRoot, result, dryRun) => {
   if (dryRun) {
-    relinka("log", `[DRY RUN] Would transform ${result.filePath}`);
+    relinka("verbose", `[DRY RUN] Would transform ${result.filePath}`);
     for (const change of result.changes) {
-      relinka("log", `  - ${change}`);
+      relinka("verbose", `  - ${change}`);
     }
     return;
   }
   const fullPath = join(projectRoot, result.filePath);
   await writeFile(fullPath, result.transformedContent);
-  relinka("log", `\u2713 Transformed ${result.filePath}`);
+  relinka("verbose", `\u2713 Transformed ${result.filePath}`);
   for (const change of result.changes) {
-    relinka("log", `  - ${change}`);
+    relinka("verbose", `  - ${change}`);
   }
 };
 const migrateProject = async (config) => {
   const { projectRoot, dryRun, backup } = config;
-  relinka("log", "\u{1F50D} Analyzing project...");
+  relinka("verbose", "\u{1F50D} Analyzing project...");
   const analysis = await analyzeProject(projectRoot);
   relinka(
     "log",
@@ -452,7 +452,7 @@ const migrateProject = async (config) => {
 `
   );
   if (backup && !dryRun) {
-    relinka("log", "\u{1F4BE} Creating backup...");
+    relinka("verbose", "\u{1F4BE} Creating backup...");
     await createBackup(projectRoot);
   }
   const transformResults = [];
@@ -460,11 +460,11 @@ const migrateProject = async (config) => {
   const errors = [];
   const warnings = [];
   try {
-    relinka("log", "\u{1F4E6} Transforming package.json...");
+    relinka("verbose", "\u{1F4E6} Transforming package.json...");
     const packageJsonResult = transformPackageJson(analysis);
     transformResults.push(packageJsonResult);
     await writeTransformedFile(projectRoot, packageJsonResult, dryRun);
-    relinka("log", "\u{1F527} Transforming source files...");
+    relinka("verbose", "\u{1F527} Transforming source files...");
     for (const sourceFile of analysis.sourceFiles.slice(0, 50)) {
       try {
         const fullPath = join(projectRoot, sourceFile);
@@ -479,7 +479,7 @@ const migrateProject = async (config) => {
       }
     }
     if (analysis.hasTests) {
-      relinka("log", "\u{1F9EA} Transforming test files...");
+      relinka("verbose", "\u{1F9EA} Transforming test files...");
       for (const testFile of analysis.testFiles.slice(0, 20)) {
         try {
           const fullPath = join(projectRoot, testFile);
@@ -495,7 +495,7 @@ const migrateProject = async (config) => {
       }
     }
     if (!dryRun) {
-      relinka("log", "\u2699\uFE0F  Generating Bun configuration...");
+      relinka("verbose", "\u2699\uFE0F  Generating Bun configuration...");
       const bunConfig = generateBunConfig(analysis);
       await writeFile(join(projectRoot, "bunfig.toml"), bunConfig);
       const dockerfile = generateDockerfile(analysis);
@@ -544,35 +544,35 @@ export async function migrateAnythingToBun({
     selective: [],
     skipFrameworks: []
   };
-  relinka("log", "\u{1F680} Starting Bun migration...");
-  relinka("log", `\u{1F4C1} Project: ${config.projectRoot}`);
-  relinka("log", `\u{1F50D} Mode: ${config.dryRun ? "DRY RUN" : "LIVE MIGRATION"}`);
-  relinka("log", "");
+  relinka("verbose", "\u{1F680} Starting Bun migration...");
+  relinka("verbose", `\u{1F4C1} Project: ${config.projectRoot}`);
+  relinka("verbose", `\u{1F50D} Mode: ${config.dryRun ? "DRY RUN" : "LIVE MIGRATION"}`);
+  relinka("verbose", "");
   try {
     const report = await migrateProject(config);
-    relinka("log", "\n\u2705 Migration complete!");
-    relinka("log", `\u{1F4CA} Files transformed: ${report.filesTransformed}`);
+    relinka("verbose", "\n\u2705 Migration complete!");
+    relinka("verbose", `\u{1F4CA} Files transformed: ${report.filesTransformed}`);
     if (report.manualSteps.length > 0) {
-      relinka("log", "\n\u{1F4CB} Manual steps required:");
+      relinka("verbose", "\n\u{1F4CB} Manual steps required:");
       for (const step of report.manualSteps) {
-        relinka("log", `  \u2022 ${step}`);
+        relinka("verbose", `  \u2022 ${step}`);
       }
     }
     if (report.warnings.length > 0) {
-      relinka("log", "\n\u26A0\uFE0F  Warnings:");
+      relinka("verbose", "\n\u26A0\uFE0F  Warnings:");
       for (const warning of report.warnings) {
-        relinka("log", `  \u2022 ${warning}`);
+        relinka("verbose", `  \u2022 ${warning}`);
       }
     }
     if (report.errors.length > 0) {
-      relinka("log", "\n\u274C Errors:");
+      relinka("verbose", "\n\u274C Errors:");
       for (const error of report.errors) {
-        relinka("log", `  \u2022 ${error}`);
+        relinka("verbose", `  \u2022 ${error}`);
       }
     }
     if (!config.dryRun) {
-      relinka("log", "\n\u{1F389} Your project has been migrated to Bun!");
-      relinka("log", "Run 'bun install' to get started.");
+      relinka("verbose", "\n\u{1F389} Your project has been migrated to Bun!");
+      relinka("verbose", "Run 'bun install' to get started.");
     }
   } catch (error) {
     relinka("error", "\u274C Migration failed:", error);

package/bin/app/migrate/codemods/console-relinka.js

@@ -130,7 +130,7 @@ export async function consoleToRelinka(input, from, to) {
     });
     if (newContent !== content) {
       content = newContent;
-      relinka("log", `\u2705 Converted ${level} calls from ${finalFrom} to ${finalTo} format`);
+      relinka("verbose", `\u2705 Converted ${level} calls from ${finalFrom} to ${finalTo} format`);
     }
   }
   if (!changes) {

package/bin/app/pack/cmd.js

@@ -139,7 +139,7 @@ const restoreFile = async (outRoot, relPath, meta, binsDir, force = false) => {
   try {
     if (!force) {
       await fs.access(dest);
-      relinka("log", `Skipping existing file (use --force to overwrite): ${relPath}`);
+      relinka("verbose", `Skipping existing file (use --force to overwrite): ${relPath}`);
       return;
     }
   } catch {
@@ -302,7 +302,7 @@ export default defineCommand({
               "warn",
               `Warning: Could not load existing templates from ${modFile}. Will create new ones.`
             );
-            relinka("log", `Error details: ${loadError.message}`);
+            relinka("verbose", `Error details: ${loadError.message}`);
           }
         }
       }
@@ -456,19 +456,19 @@ export default defineCommand({
           const newContent = code.join("\n");
           if (existingContent !== newContent) {
             if (filesToUpdate) {
-              relinka("log", `Updating specific files in template: ${tplName}`);
+              relinka("verbose", `Updating specific files in template: ${tplName}`);
             } else {
-              relinka("log", `Updating template: ${tplName}`);
+              relinka("verbose", `Updating template: ${tplName}`);
             }
           }
         } catch (error) {
           if (error.code !== "ENOENT") {
             throw error;
           }
-          relinka("log", `Creating new template: ${tplName}`);
+          relinka("verbose", `Creating new template: ${tplName}`);
         }
       } else if (!args.update) {
-        relinka("log", `Creating template: ${tplName}`);
+        relinka("verbose", `Creating template: ${tplName}`);
       }
       const filesWithErrors = Object.entries(filesRecord).filter(([_, meta]) => meta.hasError);
       if (filesWithErrors.length > 0) {
@@ -504,7 +504,7 @@ export default defineCommand({
     );
     relinka("success", `Packed ${templateDirs.length} templates into ${modFile}:`);
     for (const p of templatePaths) {
-      relinka("log", `- ${p}`);
+      relinka("verbose", `- ${p}`);
     }
     const binaryCount = Object.values(existingTemplates).reduce((count, template) => {
       return count + Object.values(template.config.files).filter((file) => file.type === "binary").length;

package/bin/app/remove/cmd.js

@@ -124,7 +124,7 @@ export default defineCommand({
           await removeDependency(name, options);
         } else {
           relinka.error(`Unknown action: ${action}`);
-          relinka.log("Available actions: remove, rm, uninstall, un, delete, del");
+          relinka.verbose("Available actions: remove, rm, uninstall, un, delete, del");
           return process.exit(1);
         }
       }

package/bin/app/rempts/cmd.js

@@ -90,7 +90,7 @@ export default defineCommand({
         await fs.ensureDir(dirPath);
         const content = generateCommandTemplate(cmdName);
         await fs.writeFile(filePath, content, "utf8");
-        relinka("log", `\u2705 Created new command: ${filePath}`);
+        relinka("verbose", `\u2705 Created new command: ${filePath}`);
       }
       if (cliFilePath) {
         relinka(
@@ -119,7 +119,7 @@ export default defineCommand({
       await fs.ensureDir(path.dirname(outPath2));
       await fs.writeFile(outPath2, exports2, "utf8");
       relinka("success", `\u2705 Generated command exports at: ${outPath2}`);
-      relinka("log", `Found ${cmdDirs2.length} command(s): ${cmdDirs2.join(", ")}`);
+      relinka("verbose", `Found ${cmdDirs2.length} command(s): ${cmdDirs2.join(", ")}`);
       return;
     }
     const root = path.resolve("src/app");
@@ -137,7 +137,7 @@ export default defineCommand({
     await fs.ensureDir(path.dirname(outPath));
     await fs.writeFile(outPath, exports, "utf8");
     relinka("success", `\u2705 Generated command exports at: ${outPath}`);
-    relinka("log", `Found ${cmdDirs.length} command(s): ${cmdDirs.join(", ")}`);
+    relinka("verbose", `Found ${cmdDirs.length} command(s): ${cmdDirs.join(", ")}`);
     if (didInit) {
       relinka(
         "log",
@@ -207,7 +207,7 @@ async function ensureCliFile(filePath) {
   if (!await fs.pathExists(resolvedPath)) {
     await fs.ensureDir(path.dirname(resolvedPath));
     await fs.writeFile(resolvedPath, cliTemplate, "utf8");
-    relinka("log", `\u2705 Created CLI entry file: ${resolvedPath}`);
+    relinka("verbose", `\u2705 Created CLI entry file: ${resolvedPath}`);
     return resolvedPath;
   }
   return "";