logger

Author: alexanderkirtzel

.github/workflows/release.yml

@@ -94,7 +94,8 @@ jobs:
         env:
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
 
-      - name: Commit version changes
+      - name: Commit version changes (stable only)
+        if: inputs.release_type == 'stable release'
         run: |
           git add -A
           git commit -m "chore: version packages" || echo "No changes to commit"

packages/cli/src/__tests__/cli.test.ts

@@ -95,7 +95,7 @@ describe('CLI Bundle Command', () => {
     expect(output.data.flows[0].stats.packages[0].name).toBe(
       '@walkeros/core@latest',
     );
-  });
+  }, 120000);
 
   it('should output JSON format for failed bundle (invalid syntax)', async () => {
     // Flow.Setup format - but bundler will fail on invalid destination code

packages/cli/src/commands/bundle/bundler.ts

@@ -84,15 +84,16 @@ export async function bundleCore(
     if (cached) {
       const cachedBuild = await getCachedBuild(configContent);
       if (cachedBuild) {
-        logger.info('✨ Using cached build');
+        logger.debug('Using cached build');
 
         // Write cached build to output
         const outputPath = path.resolve(buildOptions.output);
         await fs.ensureDir(path.dirname(outputPath));
         await fs.writeFile(outputPath, cachedBuild);
 
-        logger.gray(`Output: ${outputPath}`);
-        logger.success('✅ Build completed (from cache)');
+        const stats = await fs.stat(outputPath);
+        const sizeKB = (stats.size / 1024).toFixed(1);
+        logger.log(`Output: ${outputPath} (${sizeKB} KB, cached)`);
 
         // Return stats if requested
         if (showStats) {
@@ -121,7 +122,7 @@ export async function bundleCore(
     await fs.ensureDir(TEMP_DIR);
 
     // Step 2: Download packages
-    logger.info('📥 Downloading packages...');
+    logger.debug('Downloading packages');
     // Convert packages object to array format expected by downloadPackages
     const packagesArray = Object.entries(buildOptions.packages).map(
       ([name, packageConfig]) => ({
@@ -168,7 +169,7 @@ export async function bundleCore(
     );
 
     // Step 4: Create entry point
-    logger.info('📝 Creating entry point...');
+    logger.debug('Creating entry point');
     const entryContent = await createEntryPoint(
       flowConfig,
       buildOptions,
@@ -178,7 +179,9 @@ export async function bundleCore(
     await fs.writeFile(entryPath, entryContent);
 
     // Step 4: Bundle with esbuild
-    logger.info('⚡ Bundling with esbuild...');
+    logger.debug(
+      `Running esbuild (target: ${buildOptions.target || 'es2018'}, format: ${buildOptions.format})`,
+    );
     const outputPath = path.resolve(buildOptions.output);
 
     // Ensure output directory exists
@@ -203,7 +206,11 @@ export async function bundleCore(
       );
     }
 
-    logger.gray(`Output: ${outputPath}`);
+    // Get file size and calculate build time
+    const outputStats = await fs.stat(outputPath);
+    const sizeKB = (outputStats.size / 1024).toFixed(1);
+    const buildTime = ((Date.now() - bundleStartTime) / 1000).toFixed(1);
+    logger.log(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
 
     // Step 5: Cache the build result if caching is enabled
     if (buildOptions.cache !== false) {

packages/cli/src/commands/bundle/index.ts

@@ -7,7 +7,6 @@
 import path from 'path';
 import {
   createCommandLogger,
-  createLogger,
   createTimer,
   createSuccessOutput,
   createErrorOutput,
@@ -46,9 +45,7 @@ export async function bundleCommand(
 
   // Handle dry-run
   if (options.dryRun) {
-    logger.info(
-      `[DRY-RUN] Would execute bundle with config: ${options.config}`,
-    );
+    logger.log(`[DRY-RUN] Would execute bundle with config: ${options.config}`);
     return;
   }
 
@@ -59,7 +56,6 @@ export async function bundleCommand(
     }
 
     // Step 1: Read configuration file
-    logger.info('📦 Reading configuration...');
     // Resolve bare names to examples directory, keep paths/URLs as-is
     const configPath = resolveAsset(options.config, 'config');
     const rawConfig = await loadJsonConfig(configPath);
@@ -95,11 +91,12 @@ export async function bundleCommand(
           buildOptions.cache = options.cache;
         }
 
-        // Log flow being built (for multi-flow setups)
+        // Log flow being built
+        const configBasename = path.basename(configPath);
         if (isMultiFlow || options.all) {
-          logger.info(`\n🔧 Building flow: ${flowName}`);
+          logger.log(`Bundling ${configBasename} (flow: ${flowName})...`);
         } else {
-          logger.info('🔧 Starting bundle process...');
+          logger.log(`Bundling ${configBasename}...`);
         }
 
         // Run bundler
@@ -142,7 +139,6 @@ export async function bundleCommand(
 
     if (options.json) {
       // JSON output for CI/CD
-      const outputLogger = createLogger({ silent: false, json: false });
       const output =
         failureCount === 0
           ? createSuccessOutput(
@@ -160,20 +156,18 @@ export async function bundleCommand(
               `${failureCount} flow(s) failed to build`,
               duration,
             );
-      outputLogger.log('white', JSON.stringify(output, null, 2));
+      logger.json(output);
     } else {
       if (options.all) {
-        logger.info(`\n📊 Build Summary:`);
-        logger.info(`   Total: ${results.length}`);
-        logger.success(`   ✅ Success: ${successCount}`);
+        logger.log(
+          `\nBuild Summary: ${successCount}/${results.length} succeeded`,
+        );
         if (failureCount > 0) {
-          logger.error(`   ❌ Failed: ${failureCount}`);
+          logger.error(`Failed: ${failureCount}`);
         }
       }
 
-      if (failureCount === 0) {
-        logger.success(`\n✅ Bundle created successfully in ${timer.format()}`);
-      } else {
+      if (failureCount > 0) {
         throw new Error(`${failureCount} flow(s) failed to build`);
       }
     }
@@ -183,12 +177,10 @@ export async function bundleCommand(
 
     if (options.json) {
       // JSON error output for CI/CD
-      const outputLogger = createLogger({ silent: false, json: false });
       const output = createErrorOutput(errorMessage, duration);
-      outputLogger.log('white', JSON.stringify(output, null, 2));
+      logger.json(output);
     } else {
-      logger.error('❌ Bundle failed:');
-      logger.error(errorMessage);
+      logger.error(`Error: ${errorMessage}`);
     }
     process.exit(1);
   }

packages/cli/src/commands/bundle/package-manager.ts

@@ -152,6 +152,9 @@ export async function downloadPackages(
   const downloadQueue: Package[] = [...packages];
   const processed = new Set<string>();
 
+  // Track user-specified packages (only these are logged per design)
+  const userSpecifiedPackages = new Set(packages.map((p) => p.name));
+
   // Track packages that should use local paths (to prevent npm overwriting them)
   const localPackageMap = new Map<string, string>();
   for (const pkg of packages) {
@@ -209,7 +212,10 @@ export async function downloadPackages(
     const cachedPath = await getCachedPackagePath(pkg);
 
     if (useCache && (await isPackageCached(pkg))) {
-      logger.debug(`Using cached ${packageSpec}...`);
+      // Only log user-specified packages per design
+      if (userSpecifiedPackages.has(pkg.name)) {
+        logger.debug(`Downloading ${packageSpec} (cached)`);
+      }
       try {
         // Ensure parent directories exist for scoped packages (@scope/package)
         await fs.ensureDir(path.dirname(packageDir));
@@ -232,8 +238,6 @@ export async function downloadPackages(
       }
     }
 
-    logger.debug(`Downloading ${packageSpec}...`);
-
     try {
       // Ensure parent directories exist for scoped packages (@scope/package)
       await fs.ensureDir(path.dirname(packageDir));
@@ -260,14 +264,23 @@ export async function downloadPackages(
         `Package download timed out after ${PACKAGE_DOWNLOAD_TIMEOUT_MS / 1000}s: ${packageSpec}`,
       );
 
+      // Only log user-specified packages per design
+      if (userSpecifiedPackages.has(pkg.name)) {
+        // Get package size for display
+        const pkgStats = await fs.stat(path.join(packageDir, 'package.json'));
+        const pkgJsonSize = pkgStats.size;
+        // Estimate total package size from package.json (rough approximation)
+        const sizeKB = (pkgJsonSize / 1024).toFixed(1);
+        logger.debug(`Downloading ${packageSpec} (${sizeKB} KB)`);
+      }
+
       // Cache the downloaded package for future use
       if (useCache) {
         try {
           await fs.ensureDir(path.dirname(cachedPath));
           await fs.copy(packageDir, cachedPath);
-          logger.debug(`Cached ${packageSpec} for future use`);
         } catch (cacheError) {
-          logger.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
+          // Silent cache failures
         }
       }
 

packages/cli/src/commands/cache.ts

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import { Command } from 'commander';
 import { getTmpPath, getDefaultTmpRoot } from '../core/tmp.js';
+import { createLogger } from '../core/logger.js';
 
 export function registerCacheCommand(program: Command): void {
   const cache = program.command('cache').description('Manage the CLI cache');
@@ -11,35 +12,39 @@ export function registerCacheCommand(program: Command): void {
     .option('--packages', 'Clear only package cache')
     .option('--builds', 'Clear only build cache')
     .option('--tmp-dir <dir>', 'Custom temp directory')
+    .option('--silent', 'Suppress output')
     .action(async (options) => {
+      const logger = createLogger({ silent: options.silent });
       const tmpDir = options.tmpDir;
       if (options.packages) {
         await fs.remove(getTmpPath(tmpDir, 'cache', 'packages'));
-        console.log('Package cache cleared');
+        logger.log('Package cache cleared');
       } else if (options.builds) {
         await fs.remove(getTmpPath(tmpDir, 'cache', 'builds'));
-        console.log('Build cache cleared');
+        logger.log('Build cache cleared');
       } else {
         await fs.remove(getTmpPath(tmpDir, 'cache'));
-        console.log('All caches cleared');
+        logger.log('All caches cleared');
       }
     });
 
   cache
     .command('info')
     .description('Show cache statistics')
     .option('--tmp-dir <dir>', 'Custom temp directory')
+    .option('--silent', 'Suppress output')
     .action(async (options) => {
+      const logger = createLogger({ silent: options.silent });
       const tmpDir = options.tmpDir;
       const packagesDir = getTmpPath(tmpDir, 'cache', 'packages');
       const buildsDir = getTmpPath(tmpDir, 'cache', 'builds');
 
       const packageCount = await countEntries(packagesDir);
       const buildCount = await countEntries(buildsDir);
 
-      console.log(`Cache directory: ${getTmpPath(tmpDir, 'cache')}`);
-      console.log(`Cached packages: ${packageCount}`);
-      console.log(`Cached builds: ${buildCount}`);
+      logger.log(`Cache directory: ${getTmpPath(tmpDir, 'cache')}`);
+      logger.log(`Cached packages: ${packageCount}`);
+      logger.log(`Cached builds: ${buildCount}`);
     });
 }
 
@@ -51,10 +56,12 @@ export function registerCleanCommand(program: Command): void {
     .command('clean')
     .description('Clear the entire temp directory (.tmp/)')
     .option('--tmp-dir <dir>', 'Custom temp directory')
+    .option('--silent', 'Suppress output')
     .action(async (options) => {
+      const logger = createLogger({ silent: options.silent });
       const tmpDir = options.tmpDir || getDefaultTmpRoot();
       await fs.remove(tmpDir);
-      console.log(`Temp directory cleared: ${tmpDir}`);
+      logger.log(`Temp directory cleared: ${tmpDir}`);
     });
 }