feat(colors): implement minimal chalk replacement for styled console output

Author: mceachen

benchmark/colors.ts

@@ -0,0 +1,22 @@
+import { styleText } from "node:util";
+
+// Minimal chalk replacement built on node:util's styleText (stable since
+// v22.13), which handles TTY detection and NO_COLOR/FORCE_COLOR for us.
+// Formats are applied one at a time for compatibility with all of Node 22.x.
+const style =
+  (...formats: Parameters<typeof styleText>[0][]) =>
+  (text: string) =>
+    formats.reduce((styled, format) => styleText(format, styled), text);
+
+export const colors = {
+  red: style("red"),
+  green: style("green"),
+  yellow: style("yellow"),
+  gray: style("gray"),
+  cyan: style("cyan"),
+  bold: {
+    red: style("bold", "red"),
+    yellow: style("bold", "yellow"),
+    cyan: style("bold", "cyan"),
+  },
+};

benchmark/index.ts

@@ -1,6 +1,5 @@
 #!/usr/bin/env tsx
 
-import chalk from "chalk";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -9,6 +8,7 @@ import {
   parseCacheProfile,
   type CacheProfile,
 } from "./cache-profile.js";
+import { colors } from "./colors.js";
 import {
   createDriver,
   getAvailableDrivers,
@@ -109,7 +109,7 @@ for (let i = 0; i < args.length; i++) {
   } else if (args[i] === "--iterations" && i + 1 < args.length) {
     const iterations = Number(args[i + 1]);
     if (!Number.isInteger(iterations) || iterations < 1) {
-      console.error(chalk.red("--iterations must be a positive integer"));
+      console.error(colors.red("--iterations must be a positive integer"));
       process.exit(1);
     }
     options.iterations = iterations;
@@ -122,7 +122,7 @@ for (let i = 0; i < args.length; i++) {
       }
       options.cacheProfile = parseCacheProfile(profile);
     } catch (error) {
-      console.error(chalk.red((error as Error).message));
+      console.error(colors.red((error as Error).message));
       process.exit(1);
     }
     i++;
@@ -163,7 +163,7 @@ const driversToTest = options.drivers ?? getAvailableDrivers();
 const scenarios = getScenarios(options.filter);
 
 if (scenarios.length === 0) {
-  console.error(chalk.red(`No scenarios found matching: ${options.filter}`));
+  console.error(colors.red(`No scenarios found matching: ${options.filter}`));
   process.exit(1);
 }
 
@@ -268,9 +268,9 @@ async function inspectBenchmarkSettings(
 
 // Main benchmark function wrapped in async IIFE for CJS compatibility
 (async () => {
-  console.log(chalk.bold.cyan("🚀 SQLite Driver Performance Benchmark\n"));
-  console.log(chalk.gray(`Testing drivers: ${driversToTest.join(", ")}`));
-  console.log(chalk.gray(`Scenarios: ${scenarios.length}\n`));
+  console.log(colors.bold.cyan("🚀 SQLite Driver Performance Benchmark\n"));
+  console.log(colors.gray(`Testing drivers: ${driversToTest.join(", ")}`));
+  console.log(colors.gray(`Scenarios: ${scenarios.length}\n`));
 
   // Drivers actually available this run, in the order requested.
   const driverList = driversToTest.filter((d) =>
@@ -280,13 +280,13 @@ async function inspectBenchmarkSettings(
     throw new Error("No requested benchmark drivers are available");
   }
 
-  console.log(chalk.gray(`Cache profile: ${options.cacheProfile}`));
+  console.log(colors.gray(`Cache profile: ${options.cacheProfile}`));
   const benchmarkSettings: Record<string, BenchmarkSettings> = {};
   for (const driverName of driverList) {
     const settings = await inspectBenchmarkSettings(driverName);
     benchmarkSettings[driverName] = settings;
     console.log(
-      chalk.gray(
+      colors.gray(
         `  ${driverName}: cache_size=${settings.effectiveCacheSize} ` +
           `(packaged=${settings.initialCacheSize}), ` +
           `journal_mode=${settings.journalMode}, ` +
@@ -315,17 +315,17 @@ async function inspectBenchmarkSettings(
     const isWarmup = pass === 0;
 
     if (isWarmup) {
-      console.log(chalk.gray("Warmup pass...\n"));
+      console.log(colors.gray("Warmup pass...\n"));
     } else {
-      console.log(chalk.bold.cyan("\nMeasured pass:\n"));
+      console.log(colors.bold.cyan("\nMeasured pass:\n"));
     }
 
     for (const [scenarioKey, scenario] of scenarios) {
       if (isWarmup) {
-        process.stdout.write(chalk.gray(`\n  ${scenario.name}:`));
+        process.stdout.write(colors.gray(`\n  ${scenario.name}:`));
       } else {
-        console.log(chalk.bold.yellow(`\n📊 ${scenario.name}`));
-        console.log(chalk.gray(`   ${scenario.description}`));
+        console.log(colors.bold.yellow(`\n📊 ${scenario.name}`));
+        console.log(colors.gray(`   ${scenario.description}`));
       }
 
       if (!isWarmup) {
@@ -382,8 +382,8 @@ async function inspectBenchmarkSettings(
           } catch (err) {
             failed.add(driverName);
             const msg = `✗ Error in ${driverName}: ${(err as Error).message}`;
-            if (isWarmup) process.stdout.write(chalk.yellow(` [${msg}]`));
-            else console.error(chalk.red(`   ${msg}`));
+            if (isWarmup) process.stdout.write(colors.yellow(` [${msg}]`));
+            else console.error(colors.red(`   ${msg}`));
           }
         }
       }
@@ -396,13 +396,13 @@ async function inspectBenchmarkSettings(
 
         if (isWarmup) {
           process.stdout.write(
-            chalk.gray(
+            colors.gray(
               ` ${driverName}:${Math.round(opsPerSec).toLocaleString()}`,
             ),
           );
         } else {
           console.log(
-            chalk.green(
+            colors.green(
               `   ${driverName}: ${Math.round(opsPerSec).toLocaleString()} ops/sec ±${rme.toFixed(1)}% (${s.length} trials × ${iters[driverName].toLocaleString()} iters)`,
             ),
           );
@@ -425,7 +425,7 @@ async function inspectBenchmarkSettings(
   }
 
   // Summary
-  console.log(chalk.bold.cyan("\n\n### 📈 Summary\n"));
+  console.log(colors.bold.cyan("\n\n### 📈 Summary\n"));
 
   // Keep the configuration directly beside the copyable Markdown table. The
   // startup preamble is useful interactively, but is easy to omit when results
@@ -521,15 +521,15 @@ async function inspectBenchmarkSettings(
         "‡ batched write — one durable commit amortized over ~1000 rows, so " +
           "driver differences remain visible (don't read these as ties).",
       );
-    console.log("\n" + chalk.gray(notes.join("\n")));
+    console.log("\n" + colors.gray(notes.join("\n")));
   }
 
   // Memory usage report
   if (options.memory && global.gc) {
     global.gc();
     const memoryFinal = process.memoryUsage();
 
-    console.log(chalk.bold.cyan("\n\n### 💾 Memory Usage\n"));
+    console.log(colors.bold.cyan("\n\n### 💾 Memory Usage\n"));
 
     const formatMB = (bytes: number) =>
       `${(bytes / 1024 / 1024).toFixed(1)} MB`;
@@ -548,7 +548,7 @@ async function inspectBenchmarkSettings(
 
     console.log(
       "\n" +
-        chalk.gray(
+        colors.gray(
           "📋 Memory table generated above - copy/paste ready for documentation!",
         ),
     );
@@ -575,8 +575,8 @@ async function inspectBenchmarkSettings(
     });
     writeCharts(charts, outDir);
     console.log(
-      chalk.bold.cyan(`\n\n### 📊 Charts\n`) +
-        chalk.gray(`Wrote ${charts.size} SVG chart(s) to ${outDir}`),
+      colors.bold.cyan(`\n\n### 📊 Charts\n`) +
+        colors.gray(`Wrote ${charts.size} SVG chart(s) to ${outDir}`),
     );
   }
 

benchmark/memory-benchmark.ts

@@ -3,10 +3,10 @@
 import { createDriver, getAvailableDrivers, type Driver } from "./drivers.js";
 import { LEAK_MIN_R2, MemoryTracker } from "./memory-tracker.js";
 // import Table from 'cli-table3'; // Removed - using markdown tables instead
-import chalk from "chalk";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { colors } from "./colors.js";
 
 interface MemoryScenario {
   name: string;
@@ -208,23 +208,23 @@ Available scenarios: ${Object.keys(memoryScenarios).join(", ")}
   // Check if GC is exposed
   if (typeof global.gc !== "function") {
     console.log(
-      chalk.yellow(
+      colors.yellow(
         "⚠️  Warning: GC not exposed. Run with --expose-gc for accurate results.",
       ),
     );
     console.log(
-      chalk.gray("   tsx --expose-gc benchmark/memory-benchmark.ts\n"),
+      colors.gray("   tsx --expose-gc benchmark/memory-benchmark.ts\n"),
     );
   }
 
   const driversToTest = options.drivers ?? getAvailableDrivers();
   const scenariosToRun = options.scenarios ?? Object.keys(memoryScenarios);
 
-  console.log(chalk.bold.cyan("💾 SQLite Driver Memory Benchmark\n"));
-  console.log(chalk.gray(`Testing drivers: ${driversToTest.join(", ")}`));
-  console.log(chalk.gray(`Scenarios: ${scenariosToRun.length}`));
+  console.log(colors.bold.cyan("💾 SQLite Driver Memory Benchmark\n"));
+  console.log(colors.gray(`Testing drivers: ${driversToTest.join(", ")}`));
+  console.log(colors.gray(`Scenarios: ${scenariosToRun.length}`));
   console.log(
-    chalk.gray(
+    colors.gray(
       `Iterations: ${options.iterations ?? "auto-calibrated"} (with ${options.warmup} warmup)\n`,
     ),
   );
@@ -234,22 +234,22 @@ Available scenarios: ${Object.keys(memoryScenarios).join(", ")}
   // Test each driver
   for (const driverName of driversToTest) {
     if (!getAvailableDrivers().includes(driverName)) {
-      console.log(chalk.gray(`Skipping ${driverName} (not available)`));
+      console.log(colors.gray(`Skipping ${driverName} (not available)`));
       continue;
     }
 
-    console.log(chalk.bold.yellow(`\n📊 Testing ${driverName}`));
+    console.log(colors.bold.yellow(`\n📊 Testing ${driverName}`));
     results[driverName] = {};
 
     // Run each scenario
     for (const scenarioKey of scenariosToRun) {
       const scenario = memoryScenarios[scenarioKey];
       if (!scenario) {
-        console.log(chalk.gray(`  Skipping unknown scenario: ${scenarioKey}`));
+        console.log(colors.gray(`  Skipping unknown scenario: ${scenarioKey}`));
         continue;
       }
 
-      console.log(chalk.gray(`\n  ${scenario.name}: ${scenario.description}`));
+      console.log(colors.gray(`\n  ${scenario.name}: ${scenario.description}`));
 
       // Create temporary database
       const tempDir = mkdtempSync(join(tmpdir(), "sqlite-mem-"));
@@ -267,7 +267,7 @@ Available scenarios: ${Object.keys(memoryScenarios).join(", ")}
         // Calibrate iterations if not specified
         let iterations = options.iterations;
         if (!iterations) {
-          console.log(chalk.gray(`    Calibrating iterations...`));
+          console.log(colors.gray(`    Calibrating iterations...`));
           const calibrationStart = Date.now();
           let calibrationIterations = 0;
 
@@ -279,7 +279,7 @@ Available scenarios: ${Object.keys(memoryScenarios).join(", ")}
 
           // Use calibrated count, but ensure reasonable bounds
           iterations = Math.max(20, Math.min(200, calibrationIterations));
-          console.log(chalk.gray(`    Using ${iterations} iterations`));
+          console.log(colors.gray(`    Using ${iterations} iterations`));
         }
 
         // Check for memory leaks with configurable threshold
@@ -304,23 +304,23 @@ Available scenarios: ${Object.keys(memoryScenarios).join(", ")}
 
         // Display results
         if (leakTest.likelyLeak) {
-          console.log(chalk.red(`    ⚠️  Potential memory leak detected!`));
+          console.log(colors.red(`    ⚠️  Potential memory leak detected!`));
         } else {
-          console.log(chalk.green(`    ✓ No memory leak detected`));
+          console.log(colors.green(`    ✓ No memory leak detected`));
         }
 
         console.log(
-          chalk.gray(
+          colors.gray(
             `    Heap growth: ${leakTest.summary.heapGrowth} (R²=${leakTest.summary.heapR2})`,
           ),
         );
         console.log(
-          chalk.gray(
+          colors.gray(
             `    External growth: ${leakTest.summary.externalGrowth} (R²=${leakTest.summary.externalR2})`,
           ),
         );
         console.log(
-          chalk.gray(
+          colors.gray(
             `    Confidence: ${leakTest.heapTrend.r2 > 0.9 ? "High" : leakTest.heapTrend.r2 > 0.7 ? "Medium" : "Low"} (based on R² values)`,
           ),
         );
@@ -332,7 +332,7 @@ Available scenarios: ${Object.keys(memoryScenarios).join(", ")}
 
         await driver.close();
       } catch (error) {
-        console.error(chalk.red(`    ✗ Error: ${(error as Error).message}`));
+        console.error(colors.red(`    ✗ Error: ${(error as Error).message}`));
         results[driverName][scenarioKey] = { error: (error as Error).message };
       } finally {
         // Clean up
@@ -346,7 +346,7 @@ Available scenarios: ${Object.keys(memoryScenarios).join(", ")}
   }
 
   // Summary table
-  console.log(chalk.bold.cyan("\n\n📈 Summary\n"));
+  console.log(colors.bold.cyan("\n\n📈 Summary\n"));
 
   // Generate markdown table
   const availableDrivers = driversToTest.filter((d) =>
@@ -381,7 +381,7 @@ Available scenarios: ${Object.keys(memoryScenarios).join(", ")}
 
   console.log(
     "\n" +
-      chalk.gray(
+      colors.gray(
         "📋 Memory table generated above - copy/paste ready for documentation!",
       ),
   );
@@ -397,11 +397,11 @@ Available scenarios: ${Object.keys(memoryScenarios).join(", ")}
   }
 
   if (leaks.length > 0) {
-    console.log(chalk.bold.red("\n\n⚠️  Memory Leak Details\n"));
+    console.log(colors.bold.red("\n\n⚠️  Memory Leak Details\n"));
 
     for (const { driver, scenario, result } of leaks) {
       console.log(
-        chalk.yellow(`${driver} - ${memoryScenarios[scenario].name}:`),
+        colors.yellow(`${driver} - ${memoryScenarios[scenario].name}:`),
       );
       console.log(
         `  Heap growth: ${result.summary.heapGrowth} (R²=${result.summary.heapR2})`,

benchmark/package.json

@@ -16,8 +16,7 @@
   },
   "dependencies": {
     "@photostructure/sqlite": "file:..",
-    "better-sqlite3": "13.0.3",
-    "chalk": "^5.6.2"
+    "better-sqlite3": "13.0.3"
   },
   "devDependencies": {
     "@types/node": "26.1.1",