@weirdfingers/baseboards 0.9.5 → 0.9.7

package/dist/index.js

@@ -3218,8 +3218,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path17) {
-      let input = path17;
+    function removeDotSegments(path18) {
+      let input = path18;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3418,8 +3418,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path17, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path17 && path17 !== "/" ? path17 : void 0;
+        const [path18, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path18 && path18 !== "/" ? path18 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6473,13 +6473,13 @@ import { Command } from "commander";
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { dirname, join } from "path";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 
 // src/commands/up.ts
-import { execa as execa2 } from "execa";
-import fs5 from "fs-extra";
-import path5 from "path";
-import chalk2 from "chalk";
+import { execa as execa3 } from "execa";
+import fs6 from "fs-extra";
+import path6 from "path";
+import chalk3 from "chalk";
 import ora2 from "ora";
 import prompts2 from "prompts";
 
@@ -6709,41 +6709,120 @@ async function execAsync(command, options) {
   return execa(cmd, args, options);
 }
 
-// src/utils/monorepo-detection.ts
+// src/utils/root-package.ts
 import fs2 from "fs-extra";
 import path2 from "path";
+import chalk2 from "chalk";
+import { execa as execa2 } from "execa";
+function createRootPackageJsonContent(projectName, cliVersion) {
+  return {
+    name: projectName,
+    private: true,
+    description: "Baseboards project - AI-powered creative toolkit",
+    scripts: {
+      dev: "baseboards dev",
+      up: "baseboards up",
+      down: "baseboards down",
+      logs: "baseboards logs -f",
+      status: "baseboards status",
+      clean: "baseboards clean"
+    },
+    devDependencies: {
+      "@weirdfingers/baseboards": `^${cliVersion}`
+    }
+  };
+}
+async function generateRootPackageJson(projectDir, projectName, cliVersion) {
+  const packageJsonPath = path2.join(projectDir, "package.json");
+  if (await fs2.pathExists(packageJsonPath)) {
+    return;
+  }
+  const content = createRootPackageJsonContent(projectName, cliVersion);
+  await fs2.writeJson(packageJsonPath, content, { spaces: 2 });
+}
+async function installRootDependencies(projectDir, packageManager) {
+  const packageJsonPath = path2.join(projectDir, "package.json");
+  if (!await fs2.pathExists(packageJsonPath)) {
+    console.log(
+      chalk2.yellow(
+        "\n\u26A0\uFE0F  No package.json found at project root, skipping dependency installation"
+      )
+    );
+    return;
+  }
+  console.log(
+    chalk2.cyan(
+      `
+\u{1F4E6} Installing project dependencies with ${packageManager}...`
+    )
+  );
+  try {
+    await execa2(packageManager, ["install"], {
+      cwd: projectDir,
+      stdio: "inherit"
+    });
+    console.log(chalk2.green("\u2705 Project dependencies installed successfully"));
+    console.log(
+      chalk2.gray("   You can now use: ") + chalk2.cyan("npm run dev") + chalk2.gray(", ") + chalk2.cyan("npm run up") + chalk2.gray(", etc.")
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(
+      chalk2.red(`
+\u274C Failed to install dependencies: ${errorMessage}`)
+    );
+    console.log(chalk2.yellow("\nTroubleshooting:"));
+    console.log(
+      chalk2.gray("  \u2022 Check that package.json is valid:"),
+      chalk2.cyan(`${projectDir}/package.json`)
+    );
+    console.log(
+      chalk2.gray(`  \u2022 Ensure ${packageManager} is installed:`),
+      chalk2.cyan(`${packageManager} --version`)
+    );
+    console.log(
+      chalk2.gray("  \u2022 Try running the install manually:"),
+      chalk2.cyan(`cd ${projectDir} && ${packageManager} install`)
+    );
+    throw error;
+  }
+}
+
+// src/utils/monorepo-detection.ts
+import fs3 from "fs-extra";
+import path3 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function detectMonorepoRoot() {
   const currentFile = fileURLToPath2(import.meta.url);
-  const cliPackageDir = path2.resolve(path2.dirname(currentFile), "../..");
+  const cliPackageDir = path3.resolve(path3.dirname(currentFile), "../..");
   let currentDir = cliPackageDir;
   const maxDepth = 5;
   for (let depth = 0; depth < maxDepth; depth++) {
     try {
-      const workspaceFile = path2.join(currentDir, "pnpm-workspace.yaml");
-      if (!await fs2.pathExists(workspaceFile)) {
-        const parentDir = path2.dirname(currentDir);
+      const workspaceFile = path3.join(currentDir, "pnpm-workspace.yaml");
+      if (!await fs3.pathExists(workspaceFile)) {
+        const parentDir = path3.dirname(currentDir);
         if (parentDir === currentDir) {
           break;
         }
         currentDir = parentDir;
         continue;
       }
-      const frontendPackageJson = path2.join(
+      const frontendPackageJson = path3.join(
         currentDir,
         "packages/frontend/package.json"
       );
-      if (!await fs2.pathExists(frontendPackageJson)) {
-        const parentDir = path2.dirname(currentDir);
+      if (!await fs3.pathExists(frontendPackageJson)) {
+        const parentDir = path3.dirname(currentDir);
         if (parentDir === currentDir) {
           break;
         }
         currentDir = parentDir;
         continue;
       }
-      const packageData = await fs2.readJSON(frontendPackageJson);
+      const packageData = await fs3.readJSON(frontendPackageJson);
       if (packageData.name !== "@weirdfingers/boards") {
-        const parentDir = path2.dirname(currentDir);
+        const parentDir = path3.dirname(currentDir);
         if (parentDir === currentDir) {
           break;
         }
@@ -6752,7 +6831,7 @@ async function detectMonorepoRoot() {
       }
       return currentDir;
     } catch (error) {
-      const parentDir = path2.dirname(currentDir);
+      const parentDir = path3.dirname(currentDir);
       if (parentDir === currentDir) {
         break;
       }
@@ -6764,8 +6843,8 @@ async function detectMonorepoRoot() {
 }
 
 // src/utils/package-copy.ts
-import fs3 from "fs-extra";
-import path3 from "path";
+import fs4 from "fs-extra";
+import path4 from "path";
 function shouldCopyFile(filePath) {
   const excluded = [
     "node_modules",
@@ -6778,23 +6857,23 @@ function shouldCopyFile(filePath) {
   return !excluded.some((ex) => filePath.includes(ex));
 }
 async function copyFrontendPackage(monorepoRoot, targetDir) {
-  const sourceFrontendDir = path3.join(monorepoRoot, "packages/frontend");
-  if (!await fs3.pathExists(sourceFrontendDir)) {
+  const sourceFrontendDir = path4.join(monorepoRoot, "packages/frontend");
+  if (!await fs4.pathExists(sourceFrontendDir)) {
     throw new Error(
       `Frontend package not found at: ${sourceFrontendDir}
 The monorepo structure may be corrupted.`
     );
   }
-  await fs3.ensureDir(targetDir);
+  await fs4.ensureDir(targetDir);
   try {
-    await fs3.copy(sourceFrontendDir, targetDir, {
+    await fs4.copy(sourceFrontendDir, targetDir, {
       filter: (src) => shouldCopyFile(src),
       overwrite: true,
       errorOnExist: false
     });
   } catch (error) {
     try {
-      await fs3.remove(targetDir);
+      await fs4.remove(targetDir);
     } catch {
     }
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -6814,15 +6893,15 @@ Error: ${errorMessage}`
   }
 }
 async function updatePackageJsonForDevPackages(webDir) {
-  const packageJsonPath = path3.join(webDir, "package.json");
-  if (!await fs3.pathExists(packageJsonPath)) {
+  const packageJsonPath = path4.join(webDir, "package.json");
+  if (!await fs4.pathExists(packageJsonPath)) {
     throw new Error(
       `package.json not found at: ${packageJsonPath}
 The web directory may not be properly scaffolded.`
     );
   }
   try {
-    const packageData = await fs3.readJSON(packageJsonPath);
+    const packageData = await fs4.readJSON(packageJsonPath);
     if (packageData.dependencies && packageData.dependencies["@weirdfingers/boards"]) {
       packageData.dependencies["@weirdfingers/boards"] = "file:../frontend";
     } else if (packageData.devDependencies && packageData.devDependencies["@weirdfingers/boards"]) {
@@ -6833,7 +6912,7 @@ The web directory may not be properly scaffolded.`
 The package may not be installed or the package.json structure is unexpected.`
       );
     }
-    await fs3.writeJSON(packageJsonPath, packageData, { spaces: 2 });
+    await fs4.writeJSON(packageJsonPath, packageData, { spaces: 2 });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     if (errorMessage.includes("EACCES") || errorMessage.includes("EPERM")) {
@@ -6861,8 +6940,8 @@ Error: ${errorMessage}`
 }
 
 // src/utils/template-downloader.ts
-import fs4 from "fs-extra";
-import path4 from "path";
+import fs5 from "fs-extra";
+import path5 from "path";
 import { createHash } from "crypto";
 import { extract } from "tar";
 import { tmpdir, homedir } from "os";
@@ -7013,12 +7092,12 @@ function handleFetchError(error, context) {
   throw error;
 }
 function getCacheDir() {
-  return path4.join(homedir(), ".baseboards", "templates");
+  return path5.join(homedir(), ".baseboards", "templates");
 }
 async function ensureCacheDir() {
   const cacheDir = getCacheDir();
   try {
-    await fs4.ensureDir(cacheDir);
+    await fs5.ensureDir(cacheDir);
   } catch (error) {
     if (error.code === "EACCES" || error.code === "EPERM") {
       throw new PermissionError(
@@ -7087,15 +7166,15 @@ async function fetchTemplateManifest(version) {
   }
   await ensureCacheDir();
   const cacheDir = getCacheDir();
-  const cachedManifestPath = path4.join(cacheDir, `manifest-v${actualVersion}.json`);
-  if (await fs4.pathExists(cachedManifestPath)) {
+  const cachedManifestPath = path5.join(cacheDir, `manifest-v${actualVersion}.json`);
+  if (await fs5.pathExists(cachedManifestPath)) {
     try {
-      const cachedManifest = await fs4.readJson(cachedManifestPath);
+      const cachedManifest = await fs5.readJson(cachedManifestPath);
       if (cachedManifest.version && Array.isArray(cachedManifest.templates)) {
         return cachedManifest;
       }
     } catch (error) {
-      await fs4.remove(cachedManifestPath);
+      await fs5.remove(cachedManifestPath);
     }
   }
   const maxRetries = 3;
@@ -7142,7 +7221,7 @@ async function fetchTemplateManifest(version) {
         throw new Error("Invalid manifest structure");
       }
       try {
-        await fs4.writeJson(cachedManifestPath, manifest, { spaces: 2 });
+        await fs5.writeJson(cachedManifestPath, manifest, { spaces: 2 });
       } catch (error) {
         if (error.code === "EACCES" || error.code === "EPERM") {
         } else if (error.code === "ENOSPC") {
@@ -7191,7 +7270,7 @@ async function verifyChecksum(filePath, expectedChecksum) {
   }
   const expectedHash = expectedChecksum.replace("sha256:", "");
   const hash = createHash("sha256");
-  const fileStream = fs4.createReadStream(filePath);
+  const fileStream = fs5.createReadStream(filePath);
   return new Promise((resolve, reject) => {
     fileStream.on("data", (chunk) => {
       hash.update(chunk);
@@ -7235,13 +7314,13 @@ async function downloadTemplate(name, version, targetDir) {
     }
     await ensureCacheDir();
     const cacheDir = getCacheDir();
-    const cachedFilePath = path4.join(
+    const cachedFilePath = path5.join(
       cacheDir,
       `template-${name}-v${manifest.version}.tar.gz`
     );
     let sourceFilePath;
     let cacheHit = false;
-    if (await fs4.pathExists(cachedFilePath)) {
+    if (await fs5.pathExists(cachedFilePath)) {
       try {
         await verifyChecksum(cachedFilePath, template.checksum);
         sourceFilePath = cachedFilePath;
@@ -7252,7 +7331,7 @@ async function downloadTemplate(name, version, targetDir) {
           console.log(`Using cached template ${name}...`);
         }
       } catch (error) {
-        await fs4.remove(cachedFilePath);
+        await fs5.remove(cachedFilePath);
         if (isInteractive) {
           console.log(`
 Downloading template ${name}...`);
@@ -7283,7 +7362,7 @@ Downloading template ${name}...`);
       );
     }
     try {
-      await fs4.ensureDir(targetDir);
+      await fs5.ensureDir(targetDir);
     } catch (error) {
       if (error.code === "EACCES" || error.code === "EPERM") {
         throw new PermissionError(
@@ -7307,9 +7386,9 @@ Downloading template ${name}...`);
       console.log("Extracting template...");
     }
     const tempDir = tmpdir();
-    extractTempDir = path4.join(tempDir, `extract-${name}-${Date.now()}`);
+    extractTempDir = path5.join(tempDir, `extract-${name}-${Date.now()}`);
     try {
-      await fs4.ensureDir(extractTempDir);
+      await fs5.ensureDir(extractTempDir);
     } catch (error) {
       if (error.code === "ENOSPC") {
         throw new DiskSpaceError(
@@ -7333,11 +7412,11 @@ Downloading template ${name}...`);
       );
     }
     try {
-      const files = await fs4.readdir(extractTempDir);
+      const files = await fs5.readdir(extractTempDir);
       for (const file of files) {
-        const srcPath = path4.join(extractTempDir, file);
-        const destPath = path4.join(targetDir, file);
-        await fs4.move(srcPath, destPath, { overwrite: true });
+        const srcPath = path5.join(extractTempDir, file);
+        const destPath = path5.join(targetDir, file);
+        await fs5.move(srcPath, destPath, { overwrite: true });
       }
     } catch (error) {
       if (error.code === "EACCES" || error.code === "EPERM") {
@@ -7356,7 +7435,7 @@ Downloading template ${name}...`);
       }
       throw error;
     }
-    await fs4.remove(extractTempDir);
+    await fs5.remove(extractTempDir);
     extractTempDir = null;
     if (spinner && isInteractive) {
       spinner.succeed("Template ready");
@@ -7368,11 +7447,11 @@ Downloading template ${name}...`);
       spinner.fail("Download failed");
     }
     try {
-      if (tempFilePath && await fs4.pathExists(tempFilePath)) {
-        await fs4.remove(tempFilePath);
+      if (tempFilePath && await fs5.pathExists(tempFilePath)) {
+        await fs5.remove(tempFilePath);
       }
-      if (extractTempDir && await fs4.pathExists(extractTempDir)) {
-        await fs4.remove(extractTempDir);
+      if (extractTempDir && await fs5.pathExists(extractTempDir)) {
+        await fs5.remove(extractTempDir);
       }
     } catch (cleanupError) {
     }
@@ -7384,7 +7463,7 @@ async function downloadAndCache(version, template, cachedFilePath, spinner = nul
   const maxChecksumRetries = 2;
   for (let checksumAttempt = 1; checksumAttempt <= maxChecksumRetries; checksumAttempt++) {
     const tempDir = tmpdir();
-    const tempFilePath = path4.join(tempDir, `${template.file}.tmp-${Date.now()}`);
+    const tempFilePath = path5.join(tempDir, `${template.file}.tmp-${Date.now()}`);
     try {
       const maxDownloadRetries = 3;
       let downloadedBytes = 0;
@@ -7465,7 +7544,7 @@ async function downloadAndCache(version, template, cachedFilePath, spinner = nul
       let lastTime = Date.now();
       let lastLoaded = 0;
       const reader = response.body.getReader();
-      const fileStream = fs4.createWriteStream(tempFilePath);
+      const fileStream = fs5.createWriteStream(tempFilePath);
       try {
         while (true) {
           const { done, value } = await reader.read();
@@ -7510,7 +7589,7 @@ async function downloadAndCache(version, template, cachedFilePath, spinner = nul
         }
         await verifyChecksum(tempFilePath, template.checksum);
         try {
-          await fs4.move(tempFilePath, cachedFilePath, { overwrite: true });
+          await fs5.move(tempFilePath, cachedFilePath, { overwrite: true });
         } catch (error) {
           if (error.code === "ENOSPC") {
             throw new DiskSpaceError(
@@ -7532,8 +7611,8 @@ async function downloadAndCache(version, template, cachedFilePath, spinner = nul
       } catch (error) {
         if (error instanceof ChecksumError) {
           if (checksumAttempt < maxChecksumRetries) {
-            if (await fs4.pathExists(tempFilePath)) {
-              await fs4.remove(tempFilePath);
+            if (await fs5.pathExists(tempFilePath)) {
+              await fs5.remove(tempFilePath);
             }
             if (spinner) {
               spinner.text = `Checksum verification failed. Retrying download (attempt ${checksumAttempt + 1}/${maxChecksumRetries})...`;
@@ -7556,8 +7635,8 @@ async function downloadAndCache(version, template, cachedFilePath, spinner = nul
       }
     } catch (error) {
       try {
-        if (await fs4.pathExists(tempFilePath)) {
-          await fs4.remove(tempFilePath);
+        if (await fs5.pathExists(tempFilePath)) {
+          await fs5.remove(tempFilePath);
         }
       } catch (cleanupError) {
       }
@@ -7574,12 +7653,12 @@ async function clearCache() {
   const cacheDir = getCacheDir();
   await ensureCacheDir();
   try {
-    const files = await fs4.readdir(cacheDir);
+    const files = await fs5.readdir(cacheDir);
     for (const file of files) {
-      const filePath = path4.join(cacheDir, file);
-      const stat = await fs4.stat(filePath);
+      const filePath = path5.join(cacheDir, file);
+      const stat = await fs5.stat(filePath);
       if (stat.isFile()) {
-        await fs4.remove(filePath);
+        await fs5.remove(filePath);
       }
     }
   } catch (error) {
@@ -7601,34 +7680,34 @@ async function validateTemplate(templateName, version) {
   }
 }
 async function installFrontendDependencies(ctx) {
-  const webDir = path5.join(ctx.dir, "web");
-  const packageJsonPath = path5.join(webDir, "package.json");
-  if (!fs5.existsSync(packageJsonPath)) {
-    console.log(chalk2.yellow("\n\u26A0\uFE0F  No package.json found in web directory, skipping dependency installation"));
+  const webDir = path6.join(ctx.dir, "web");
+  const packageJsonPath = path6.join(webDir, "package.json");
+  if (!fs6.existsSync(packageJsonPath)) {
+    console.log(chalk3.yellow("\n\u26A0\uFE0F  No package.json found in web directory, skipping dependency installation"));
     return;
   }
   if (!ctx.packageManager) {
     ctx.packageManager = await promptPackageManager();
   }
   const packageManager = ctx.packageManager;
-  console.log(chalk2.cyan(`
+  console.log(chalk3.cyan(`
 \u{1F4E6} Installing frontend dependencies with ${packageManager}...`));
   const installCmd = "install";
   try {
-    await execa2(packageManager, [installCmd], {
+    await execa3(packageManager, [installCmd], {
       cwd: webDir,
       stdio: "inherit"
       // Show install output to user
     });
-    console.log(chalk2.green("\u2705 Dependencies installed successfully\n"));
+    console.log(chalk3.green("\u2705 Dependencies installed successfully\n"));
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(chalk2.red(`
+    console.error(chalk3.red(`
 \u274C Failed to install dependencies: ${errorMessage}`));
-    console.log(chalk2.yellow("\nTroubleshooting:"));
-    console.log(chalk2.gray("  \u2022 Check that package.json is valid:"), chalk2.cyan(`${webDir}/package.json`));
-    console.log(chalk2.gray(`  \u2022 Ensure ${packageManager} is installed:`), chalk2.cyan(`${packageManager} --version`));
-    console.log(chalk2.gray("  \u2022 Try running the install manually:"), chalk2.cyan(`cd ${webDir} && ${packageManager} install`));
+    console.log(chalk3.yellow("\nTroubleshooting:"));
+    console.log(chalk3.gray("  \u2022 Check that package.json is valid:"), chalk3.cyan(`${webDir}/package.json`));
+    console.log(chalk3.gray(`  \u2022 Ensure ${packageManager} is installed:`), chalk3.cyan(`${packageManager} --version`));
+    console.log(chalk3.gray("  \u2022 Try running the install manually:"), chalk3.cyan(`cd ${webDir} && ${packageManager} install`));
     throw error;
   }
 }
@@ -7659,12 +7738,12 @@ async function promptTemplateSelection(version) {
   }
 }
 async function up(directory, options) {
-  console.log(chalk2.blue.bold("\n\u{1F3A8} Baseboards CLI\n"));
+  console.log(chalk3.blue.bold("\n\u{1F3A8} Baseboards CLI\n"));
   const spinner = ora2("Checking prerequisites...").start();
   await assertPrerequisites();
   spinner.succeed("Prerequisites OK");
-  const dir = path5.resolve(process.cwd(), directory);
-  const name = path5.basename(dir);
+  const dir = path6.resolve(process.cwd(), directory);
+  const name = path6.basename(dir);
   const version = getCliVersion();
   let customPorts = {};
   if (options.ports) {
@@ -7720,17 +7799,17 @@ async function up(directory, options) {
         await cleanupDockerVolumes(ctx);
       } else if (!ctx.isScaffolded) {
         console.log(
-          chalk2.yellow(
+          chalk3.yellow(
             "\n\u26A0\uFE0F  Existing Docker volumes detected from a previous installation"
           )
         );
         console.log(
-          chalk2.gray(
+          chalk3.gray(
             "   To avoid password mismatch errors, you can start fresh or cancel."
           )
         );
         console.log(
-          chalk2.gray(
+          chalk3.gray(
             "   Starting fresh will delete ALL existing data (boards, generated images, users)."
           )
         );
@@ -7741,22 +7820,22 @@ async function up(directory, options) {
           initial: true
         });
         if (response.cleanVolumes === void 0) {
-          console.log(chalk2.yellow("\n\u26A0\uFE0F  Cancelled by user"));
+          console.log(chalk3.yellow("\n\u26A0\uFE0F  Cancelled by user"));
           process.exit(0);
         }
         if (response.cleanVolumes) {
           await cleanupDockerVolumes(ctx);
         } else {
           console.log(
-            chalk2.yellow(
+            chalk3.yellow(
               "\n\u26A0\uFE0F  Proceeding without cleaning volumes. If you encounter password errors:"
             )
           );
           console.log(
-            chalk2.cyan("   baseboards up --fresh") + chalk2.gray(" (start fresh)")
+            chalk3.cyan("   baseboards up --fresh") + chalk3.gray(" (start fresh)")
           );
           console.log(
-            chalk2.cyan("   baseboards down --volumes && baseboards up") + chalk2.gray(" (manual cleanup)")
+            chalk3.cyan("   baseboards down --volumes && baseboards up") + chalk3.gray(" (manual cleanup)")
           );
         }
       }
@@ -7764,24 +7843,24 @@ async function up(directory, options) {
   }
   if (!ctx.isScaffolded) {
     console.log(
-      chalk2.cyan(`
-\u{1F4E6} Scaffolding new project: ${chalk2.bold(name)}`)
+      chalk3.cyan(`
+\u{1F4E6} Scaffolding new project: ${chalk3.bold(name)}`)
     );
     await scaffoldProject(ctx);
   } else {
     console.log(
-      chalk2.green(`
-\u2705 Project already scaffolded: ${chalk2.bold(name)}`)
+      chalk3.green(`
+\u2705 Project already scaffolded: ${chalk3.bold(name)}`)
     );
   }
   if (ctx.devPackages && ctx.monorepoRoot) {
     const spinner2 = ora2("Copying @weirdfingers/boards source from monorepo...").start();
     try {
-      const targetFrontend = path5.join(ctx.dir, "frontend");
+      const targetFrontend = path6.join(ctx.dir, "frontend");
       await copyFrontendPackage(ctx.monorepoRoot, targetFrontend);
       spinner2.succeed("Package source copied");
       spinner2.start("Linking local package...");
-      const webDir = path5.join(ctx.dir, "web");
+      const webDir = path6.join(ctx.dir, "web");
       await updatePackageJsonForDevPackages(webDir);
       spinner2.succeed("Local package linked successfully");
     } catch (error) {
@@ -7799,28 +7878,34 @@ async function up(directory, options) {
   if (isFreshScaffold) {
     await promptForApiKeys(ctx);
   }
-  const apiEnvPath = path5.join(ctx.dir, "api/.env");
+  if (isFreshScaffold) {
+    if (!ctx.packageManager) {
+      ctx.packageManager = await promptPackageManager();
+    }
+    await installRootDependencies(ctx.dir, ctx.packageManager);
+  }
+  const apiEnvPath = path6.join(ctx.dir, "api/.env");
   const missingKeys = detectMissingProviderKeys(apiEnvPath);
   if (missingKeys.length > 0) {
-    console.log(chalk2.yellow("\n\u26A0\uFE0F  Provider API keys not configured!"));
-    console.log(chalk2.gray("   Add at least one API key to api/.env:"));
+    console.log(chalk3.yellow("\n\u26A0\uFE0F  Provider API keys not configured!"));
+    console.log(chalk3.gray("   Add at least one API key to api/.env:"));
     console.log(
-      chalk2.cyan("   \u2022 REPLICATE_API_TOKEN") + chalk2.gray(" - https://replicate.com/account/api-tokens")
+      chalk3.cyan("   \u2022 REPLICATE_API_TOKEN") + chalk3.gray(" - https://replicate.com/account/api-tokens")
     );
     console.log(
-      chalk2.cyan("   \u2022 FAL_KEY") + chalk2.gray(" - https://fal.ai/dashboard/keys")
+      chalk3.cyan("   \u2022 FAL_KEY") + chalk3.gray(" - https://fal.ai/dashboard/keys")
     );
     console.log(
-      chalk2.cyan("   \u2022 KIE_API_KEY") + chalk2.gray(" - https://kie.ai/dashboard")
+      chalk3.cyan("   \u2022 KIE_API_KEY") + chalk3.gray(" - https://kie.ai/dashboard")
     );
     console.log(
-      chalk2.cyan("   \u2022 OPENAI_API_KEY") + chalk2.gray(" - https://platform.openai.com/api-keys")
+      chalk3.cyan("   \u2022 OPENAI_API_KEY") + chalk3.gray(" - https://platform.openai.com/api-keys")
     );
     console.log(
-      chalk2.cyan("   \u2022 GOOGLE_API_KEY") + chalk2.gray(" - https://makersuite.google.com/app/apikey")
+      chalk3.cyan("   \u2022 GOOGLE_API_KEY") + chalk3.gray(" - https://makersuite.google.com/app/apikey")
     );
     console.log(
-      chalk2.gray(
+      chalk3.gray(
         "\n   The app will start, but image generation won't work without keys.\n"
       )
     );
@@ -7838,7 +7923,7 @@ async function up(directory, options) {
     } catch (error) {
       const maybeProcError = error;
       if (maybeProcError.signal === "SIGINT" || maybeProcError.exitCode === 130) {
-        console.log(chalk2.yellow("\n\n\u26A0\uFE0F  Interrupted - services stopped"));
+        console.log(chalk3.yellow("\n\n\u26A0\uFE0F  Interrupted - services stopped"));
         process.exit(0);
       }
       throw error;
@@ -7846,29 +7931,32 @@ async function up(directory, options) {
   }
 }
 async function scaffoldProject(ctx) {
-  fs5.ensureDirSync(ctx.dir);
+  fs6.ensureDirSync(ctx.dir);
   await downloadTemplate(ctx.template, ctx.version, ctx.dir);
   const spinner = ora2("Creating data directories...").start();
-  fs5.ensureDirSync(path5.join(ctx.dir, "data/storage"));
+  fs6.ensureDirSync(path6.join(ctx.dir, "data/storage"));
   spinner.succeed("Data directories created");
-  console.log(chalk2.green("   \u2728 Project scaffolded successfully!"));
+  spinner.start("Generating project configuration...");
+  await generateRootPackageJson(ctx.dir, ctx.name, ctx.version);
+  spinner.succeed("Project configuration created");
+  console.log(chalk3.green("   \u2728 Project scaffolded successfully!"));
 }
 async function ensureEnvFiles(ctx) {
   const spinner = ora2("Configuring environment...").start();
-  const webEnvPath = path5.join(ctx.dir, "web/.env");
-  const webEnvExamplePath = path5.join(ctx.dir, "web/.env.example");
-  if (!fs5.existsSync(webEnvPath) && fs5.existsSync(webEnvExamplePath)) {
-    let webEnv = fs5.readFileSync(webEnvExamplePath, "utf-8");
+  const webEnvPath = path6.join(ctx.dir, "web/.env");
+  const webEnvExamplePath = path6.join(ctx.dir, "web/.env.example");
+  if (!fs6.existsSync(webEnvPath) && fs6.existsSync(webEnvExamplePath)) {
+    let webEnv = fs6.readFileSync(webEnvExamplePath, "utf-8");
     webEnv = webEnv.replace(
       "http://localhost:8800",
       `http://localhost:${ctx.ports.api}`
     );
-    fs5.writeFileSync(webEnvPath, webEnv);
+    fs6.writeFileSync(webEnvPath, webEnv);
   }
-  const apiEnvPath = path5.join(ctx.dir, "api/.env");
-  const apiEnvExamplePath = path5.join(ctx.dir, "api/.env.example");
-  if (!fs5.existsSync(apiEnvPath) && fs5.existsSync(apiEnvExamplePath)) {
-    let apiEnv = fs5.readFileSync(apiEnvExamplePath, "utf-8");
+  const apiEnvPath = path6.join(ctx.dir, "api/.env");
+  const apiEnvExamplePath = path6.join(ctx.dir, "api/.env.example");
+  if (!fs6.existsSync(apiEnvPath) && fs6.existsSync(apiEnvExamplePath)) {
+    let apiEnv = fs6.readFileSync(apiEnvExamplePath, "utf-8");
     if (apiEnv.includes("BOARDS_JWT_SECRET=\n") || apiEnv.includes("BOARDS_JWT_SECRET=\r\n")) {
       const jwtSecret = generateSecret(32);
       apiEnv = apiEnv.replace(
@@ -7876,12 +7964,12 @@ async function ensureEnvFiles(ctx) {
         `BOARDS_JWT_SECRET=${jwtSecret}`
       );
     }
-    fs5.writeFileSync(apiEnvPath, apiEnv);
+    fs6.writeFileSync(apiEnvPath, apiEnv);
   }
-  const dockerEnvPath = path5.join(ctx.dir, "docker/.env");
-  const dockerEnvExamplePath = path5.join(ctx.dir, "docker/env.example");
-  if (!fs5.existsSync(dockerEnvPath) && fs5.existsSync(dockerEnvExamplePath)) {
-    let dockerEnv = fs5.readFileSync(dockerEnvExamplePath, "utf-8");
+  const dockerEnvPath = path6.join(ctx.dir, "docker/.env");
+  const dockerEnvExamplePath = path6.join(ctx.dir, "docker/env.example");
+  if (!fs6.existsSync(dockerEnvPath) && fs6.existsSync(dockerEnvExamplePath)) {
+    let dockerEnv = fs6.readFileSync(dockerEnvExamplePath, "utf-8");
     const dbPassword = generatePassword(24);
     const dbPasswordEncoded = encodeURIComponent(dbPassword);
     dockerEnv = dockerEnv.replace(
@@ -7895,18 +7983,19 @@ async function ensureEnvFiles(ctx) {
     dockerEnv = dockerEnv.replace(/WEB_PORT=.*/g, `WEB_PORT=${ctx.ports.web}`);
     dockerEnv = dockerEnv.replace(/API_PORT=.*/g, `API_PORT=${ctx.ports.api}`);
     dockerEnv = dockerEnv.replace(/VERSION=.*/g, `VERSION=${ctx.version}`);
+    dockerEnv = dockerEnv.replace(/BACKEND_VERSION=.*/g, `BACKEND_VERSION=${ctx.version}`);
     dockerEnv = dockerEnv.replace(
       /PROJECT_NAME=.*/g,
       `PROJECT_NAME=${ctx.name}`
     );
-    fs5.writeFileSync(dockerEnvPath, dockerEnv);
+    fs6.writeFileSync(dockerEnvPath, dockerEnv);
   }
   spinner.succeed("Environment configured");
 }
 async function promptForApiKeys(ctx) {
-  console.log(chalk2.cyan("\n\u{1F511} API Key Configuration"));
-  console.log(chalk2.gray("Add API keys to enable image generation providers"));
-  console.log(chalk2.gray("Press Enter to skip any key\n"));
+  console.log(chalk3.cyan("\n\u{1F511} API Key Configuration"));
+  console.log(chalk3.gray("Add API keys to enable image generation providers"));
+  console.log(chalk3.gray("Press Enter to skip any key\n"));
   const response = await prompts2([
     {
       type: "password",
@@ -7947,8 +8036,8 @@ async function promptForApiKeys(ctx) {
     apiKeys.OPENAI_API_KEY = response.OPENAI_API_KEY.trim();
   }
   if (Object.keys(apiKeys).length > 0) {
-    const apiEnvPath = path5.join(ctx.dir, "api/.env");
-    let apiEnv = fs5.readFileSync(apiEnvPath, "utf-8");
+    const apiEnvPath = path6.join(ctx.dir, "api/.env");
+    let apiEnv = fs6.readFileSync(apiEnvPath, "utf-8");
     const jsonKeys = JSON.stringify(apiKeys);
     if (apiEnv.includes("BOARDS_GENERATOR_API_KEYS=")) {
       apiEnv = apiEnv.replace(
@@ -7964,14 +8053,14 @@ BOARDS_GENERATOR_API_KEYS=${jsonKeys}
 `
       );
     }
-    fs5.writeFileSync(apiEnvPath, apiEnv);
-    console.log(chalk2.green("\n\u2705 API keys saved to api/.env"));
+    fs6.writeFileSync(apiEnvPath, apiEnv);
+    console.log(chalk3.green("\n\u2705 API keys saved to api/.env"));
     console.log(
-      chalk2.gray("   You can edit this file anytime to add/update keys\n")
+      chalk3.gray("   You can edit this file anytime to add/update keys\n")
     );
   } else {
-    console.log(chalk2.yellow("\n\u26A0\uFE0F  No API keys provided"));
-    console.log(chalk2.gray("   You can add them later by editing api/.env\n"));
+    console.log(chalk3.yellow("\n\u26A0\uFE0F  No API keys provided"));
+    console.log(chalk3.gray("   You can add them later by editing api/.env\n"));
   }
 }
 function getComposeFiles(ctx) {
@@ -7993,8 +8082,8 @@ async function startDockerCompose(ctx) {
   const spinner = ora2("Starting Docker Compose...").start();
   const composeFiles = getComposeFiles(ctx);
   for (const file of composeFiles) {
-    const filePath = path5.join(ctx.dir, file);
-    if (!fs5.existsSync(filePath)) {
+    const filePath = path6.join(ctx.dir, file);
+    if (!fs6.existsSync(filePath)) {
       spinner.fail(`Compose file not found: ${file}`);
       throw new Error(`Compose file not found: ${file}`);
     }
@@ -8007,7 +8096,7 @@ async function startDockerCompose(ctx) {
     "--remove-orphans"
   ];
   try {
-    await execa2("docker", composeArgs, {
+    await execa3("docker", composeArgs, {
       cwd: ctx.dir,
       stdio: "inherit"
     });
@@ -8019,11 +8108,11 @@ async function startDockerCompose(ctx) {
 }
 async function attachToLogs(ctx) {
   console.log(
-    chalk2.gray("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")
+    chalk3.gray("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")
   );
-  console.log(chalk2.gray("Streaming logs... (Press Ctrl+C to stop)\n"));
+  console.log(chalk3.gray("Streaming logs... (Press Ctrl+C to stop)\n"));
   const composeArgs = [...getComposeBaseArgs(ctx), "logs", "-f"];
-  await execa2("docker", composeArgs, {
+  await execa3("docker", composeArgs, {
     cwd: ctx.dir,
     stdio: "inherit"
   });
@@ -8037,7 +8126,7 @@ async function waitForHealthy(ctx) {
   const maxWaitMs = 12e4;
   const checkHealth = async () => {
     try {
-      const { stdout } = await execa2(
+      const { stdout } = await execa3(
         "docker",
         [...getComposeBaseArgs(ctx), "ps", "--format", "json"],
         {
@@ -8067,21 +8156,21 @@ async function waitForHealthy(ctx) {
   } else {
     spinner.warn("Services taking longer than expected...");
     console.log(
-      chalk2.yellow(
+      chalk3.yellow(
         "\n\u26A0\uFE0F  Health check timeout. Services may still be starting."
       )
     );
     console.log(
-      chalk2.gray("   Run"),
-      chalk2.cyan("baseboards logs"),
-      chalk2.gray("to check progress.")
+      chalk3.gray("   Run"),
+      chalk3.cyan("baseboards logs"),
+      chalk3.gray("to check progress.")
     );
   }
 }
 async function runMigrations(ctx) {
   const spinner = ora2("Running database migrations...").start();
   try {
-    const { stdout } = await execa2(
+    const { stdout } = await execa3(
       "docker",
       [
         ...getComposeBaseArgs(ctx),
@@ -8097,12 +8186,12 @@ async function runMigrations(ctx) {
       }
     );
     if (stdout && (stdout.includes("Running upgrade") || process.env.DEBUG)) {
-      console.log(chalk2.gray("\n   Migration output:"));
-      console.log(chalk2.gray("   " + stdout.split("\n").join("\n   ")));
+      console.log(chalk3.gray("\n   Migration output:"));
+      console.log(chalk3.gray("   " + stdout.split("\n").join("\n   ")));
     }
     spinner.succeed("Database migrations complete");
     spinner.start("Restarting API to apply migrations...");
-    await execa2(
+    await execa3(
       "docker",
       [...getComposeBaseArgs(ctx), "restart", "api"],
       {
@@ -8117,42 +8206,42 @@ async function runMigrations(ctx) {
     const isPasswordError = errorMessage.includes("password authentication failed") || errorMessage.includes("InvalidPasswordError");
     if (isPasswordError) {
       console.log(
-        chalk2.red(
+        chalk3.red(
           "\n\u274C Database password mismatch - cannot connect to existing database"
         )
       );
       console.log(
-        chalk2.yellow(
+        chalk3.yellow(
           "   Existing database volumes have a different password than the current configuration."
         )
       );
-      console.log(chalk2.yellow("\n   To fix this, choose one of:"));
+      console.log(chalk3.yellow("\n   To fix this, choose one of:"));
       console.log(
-        chalk2.cyan("   1. Start fresh (deletes data):") + chalk2.gray(" baseboards down --volumes && baseboards up")
+        chalk3.cyan("   1. Start fresh (deletes data):") + chalk3.gray(" baseboards down --volumes && baseboards up")
       );
       console.log(
-        chalk2.cyan("   2. Start fresh automatically:") + chalk2.gray(" baseboards up --fresh")
+        chalk3.cyan("   2. Start fresh automatically:") + chalk3.gray(" baseboards up --fresh")
       );
       console.log(
-        chalk2.gray(
+        chalk3.gray(
           "\n   This usually happens when project files were deleted but Docker volumes remain."
         )
       );
     } else {
       console.log(
-        chalk2.red(
+        chalk3.red(
           "\n\u274C Database migrations failed"
         )
       );
-      console.log(chalk2.gray("\n   Error details:"));
-      console.log(chalk2.gray("   " + errorMessage));
+      console.log(chalk3.gray("\n   Error details:"));
+      console.log(chalk3.gray("   " + errorMessage));
       console.log(
-        chalk2.yellow(
+        chalk3.yellow(
           "\n   You can try running migrations manually:"
         )
       );
       console.log(
-        chalk2.cyan("   docker compose exec api alembic upgrade head")
+        chalk3.cyan("   docker compose exec api alembic upgrade head")
       );
     }
     throw new Error("Database migrations failed");
@@ -8168,84 +8257,87 @@ function getDevCommand(pm) {
   return commands[pm];
 }
 function printDefaultSuccessMessage(ctx, hasKeyWarning) {
-  console.log(chalk2.green.bold("\n\u2705 Baseboards is running!\n"));
+  console.log(chalk3.green.bold("\n\u2705 Baseboards is running!\n"));
   console.log(
-    chalk2.cyan("   Web:     "),
-    chalk2.underline(`http://localhost:${ctx.ports.web}`)
+    chalk3.cyan("   Web:     "),
+    chalk3.underline(`http://localhost:${ctx.ports.web}`)
   );
   console.log(
-    chalk2.cyan("   API:     "),
-    chalk2.underline(`http://localhost:${ctx.ports.api}`)
+    chalk3.cyan("   API:     "),
+    chalk3.underline(`http://localhost:${ctx.ports.api}`)
   );
   console.log(
-    chalk2.cyan("   GraphQL: "),
-    chalk2.underline(`http://localhost:${ctx.ports.api}/graphql`)
+    chalk3.cyan("   GraphQL: "),
+    chalk3.underline(`http://localhost:${ctx.ports.api}/graphql`)
   );
   if (hasKeyWarning) {
-    console.log(chalk2.yellow("\n\u26A0\uFE0F  Remember to configure provider API keys!"));
-    console.log(chalk2.gray("   Edit:"), chalk2.cyan("api/.env"));
+    console.log(chalk3.yellow("\n\u26A0\uFE0F  Remember to configure provider API keys!"));
+    console.log(chalk3.gray("   Edit:"), chalk3.cyan("api/.env"));
     console.log(
-      chalk2.gray("   Docs:"),
-      chalk2.cyan("https://baseboards.dev/docs/setup")
+      chalk3.gray("   Docs:"),
+      chalk3.cyan("https://baseboards.dev/docs/setup")
     );
   }
-  console.log(chalk2.gray("\nView logs:"), chalk2.cyan(`baseboards logs ${ctx.name} -f`));
-  console.log(chalk2.gray("Stop:     "), chalk2.cyan(`baseboards down ${ctx.name}`));
+  console.log(chalk3.gray("\nUseful commands:"));
+  console.log(chalk3.gray("  View logs: "), chalk3.cyan("npm run logs"));
+  console.log(chalk3.gray("  Stop:      "), chalk3.cyan("npm run down"));
   console.log();
 }
 function printAppDevSuccessMessage(ctx, hasKeyWarning) {
-  console.log(chalk2.green.bold("\n\u2705 Backend services are running!\n"));
+  console.log(chalk3.green.bold("\n\u2705 Backend services are running!\n"));
   console.log(
-    chalk2.cyan("   API:     "),
-    chalk2.underline(`http://localhost:${ctx.ports.api}`)
+    chalk3.cyan("   API:     "),
+    chalk3.underline(`http://localhost:${ctx.ports.api}`)
   );
   console.log(
-    chalk2.cyan("   GraphQL: "),
-    chalk2.underline(`http://localhost:${ctx.ports.api}/graphql`)
+    chalk3.cyan("   GraphQL: "),
+    chalk3.underline(`http://localhost:${ctx.ports.api}/graphql`)
   );
-  console.log(chalk2.cyan("\nTo start the frontend:\n"));
-  const relativeWebPath = path5.relative(process.cwd(), path5.join(ctx.dir, "web"));
+  console.log(chalk3.cyan("\nTo start the frontend:\n"));
+  const relativeWebPath = path6.relative(process.cwd(), path6.join(ctx.dir, "web"));
   const cdCommand = relativeWebPath || "web";
   const packageManager = ctx.packageManager || "pnpm";
   const devCommand = getDevCommand(packageManager);
-  console.log(chalk2.cyan(`   cd ${cdCommand}`));
-  console.log(chalk2.cyan(`   ${devCommand}`));
-  console.log(chalk2.gray("\nThe frontend will be available at"), chalk2.underline("http://localhost:3000"));
+  console.log(chalk3.cyan(`   cd ${cdCommand}`));
+  console.log(chalk3.cyan(`   ${devCommand}`));
+  console.log(chalk3.gray("\nThe frontend will be available at"), chalk3.underline("http://localhost:3000"));
   if (hasKeyWarning) {
-    console.log(chalk2.yellow("\n\u26A0\uFE0F  Remember to configure provider API keys!"));
-    console.log(chalk2.gray("   Edit:"), chalk2.cyan("api/.env"));
+    console.log(chalk3.yellow("\n\u26A0\uFE0F  Remember to configure provider API keys!"));
+    console.log(chalk3.gray("   Edit:"), chalk3.cyan("api/.env"));
   }
-  console.log(chalk2.gray("\nView logs:"), chalk2.cyan(`baseboards logs ${ctx.name} -f`));
-  console.log(chalk2.gray("Stop:     "), chalk2.cyan(`baseboards down ${ctx.name}`));
+  console.log(chalk3.gray("\nUseful commands:"));
+  console.log(chalk3.gray("  View logs: "), chalk3.cyan("npm run logs"));
+  console.log(chalk3.gray("  Stop:      "), chalk3.cyan("npm run down"));
   console.log();
 }
 function printDevPackagesSuccessMessage(ctx, hasKeyWarning) {
-  console.log(chalk2.green.bold("\n\u2705 Backend services are running!"));
-  console.log(chalk2.green.bold("\u2705 Local @weirdfingers/boards package linked!\n"));
+  console.log(chalk3.green.bold("\n\u2705 Backend services are running!"));
+  console.log(chalk3.green.bold("\u2705 Local @weirdfingers/boards package linked!\n"));
   console.log(
-    chalk2.cyan("   API:     "),
-    chalk2.underline(`http://localhost:${ctx.ports.api}`)
+    chalk3.cyan("   API:     "),
+    chalk3.underline(`http://localhost:${ctx.ports.api}`)
   );
   console.log(
-    chalk2.cyan("   GraphQL: "),
-    chalk2.underline(`http://localhost:${ctx.ports.api}/graphql`)
+    chalk3.cyan("   GraphQL: "),
+    chalk3.underline(`http://localhost:${ctx.ports.api}/graphql`)
   );
-  console.log(chalk2.cyan("\n\u{1F4E6} Package development workflow:\n"));
-  console.log(chalk2.gray("   1. Edit package source:"));
-  console.log(chalk2.cyan(`      ${ctx.dir}/frontend/src/`));
-  console.log(chalk2.gray("\n   2. Start the frontend:"));
-  console.log(chalk2.cyan(`      cd ${ctx.dir}/web`));
-  console.log(chalk2.cyan(`      pnpm install`));
-  console.log(chalk2.cyan(`      pnpm dev`));
-  console.log(chalk2.gray("\n   3. Changes to the package will hot-reload automatically"));
-  console.log(chalk2.gray(`
+  console.log(chalk3.cyan("\n\u{1F4E6} Package development workflow:\n"));
+  console.log(chalk3.gray("   1. Edit package source:"));
+  console.log(chalk3.cyan(`      ${ctx.dir}/frontend/src/`));
+  console.log(chalk3.gray("\n   2. Start the frontend:"));
+  console.log(chalk3.cyan(`      cd ${ctx.dir}/web`));
+  console.log(chalk3.cyan(`      pnpm install`));
+  console.log(chalk3.cyan(`      pnpm dev`));
+  console.log(chalk3.gray("\n   3. Changes to the package will hot-reload automatically"));
+  console.log(chalk3.gray(`
    Frontend will be available at http://localhost:3000`));
   if (hasKeyWarning) {
-    console.log(chalk2.yellow("\n\u26A0\uFE0F  Remember to configure provider API keys!"));
-    console.log(chalk2.gray("   Edit:"), chalk2.cyan("api/.env"));
+    console.log(chalk3.yellow("\n\u26A0\uFE0F  Remember to configure provider API keys!"));
+    console.log(chalk3.gray("   Edit:"), chalk3.cyan("api/.env"));
   }
-  console.log(chalk2.gray("\nView logs:"), chalk2.cyan(`baseboards logs ${ctx.name} -f`));
-  console.log(chalk2.gray("Stop:     "), chalk2.cyan(`baseboards down ${ctx.name}`));
+  console.log(chalk3.gray("\nUseful commands:"));
+  console.log(chalk3.gray("  View logs: "), chalk3.cyan("npm run logs"));
+  console.log(chalk3.gray("  Stop:      "), chalk3.cyan("npm run down"));
   console.log();
 }
 function printSuccessMessage(ctx, detached, hasKeyWarning) {
@@ -8259,7 +8351,7 @@ function printSuccessMessage(ctx, detached, hasKeyWarning) {
 }
 async function checkForExistingVolumes() {
   try {
-    const { stdout } = await execa2("docker", [
+    const { stdout } = await execa3("docker", [
       "volume",
       "ls",
       "--format",
@@ -8276,14 +8368,14 @@ async function cleanupDockerVolumes(ctx) {
   const spinner = ora2("Cleaning up Docker volumes...").start();
   try {
     if (ctx.isScaffolded) {
-      await execa2("docker", [...getComposeBaseArgs(ctx), "down", "-v"], {
+      await execa3("docker", [...getComposeBaseArgs(ctx), "down", "-v"], {
         cwd: ctx.dir
       });
     } else {
       const volumesToRemove = ["baseboards_db-data", "baseboards_api-storage"];
       for (const volumeName of volumesToRemove) {
         try {
-          await execa2("docker", ["volume", "rm", volumeName]);
+          await execa3("docker", ["volume", "rm", volumeName]);
           spinner.text = `Removing volume ${volumeName}...`;
         } catch {
         }
@@ -8293,25 +8385,25 @@ async function cleanupDockerVolumes(ctx) {
   } catch (error) {
     spinner.fail("Failed to clean up volumes");
     console.log(
-      chalk2.yellow(
+      chalk3.yellow(
         "\n\u26A0\uFE0F  Could not clean up volumes automatically. Try manually:"
       )
     );
-    console.log(chalk2.cyan("   docker volume rm baseboards_db-data"));
+    console.log(chalk3.cyan("   docker volume rm baseboards_db-data"));
     throw error;
   }
 }
 
 // src/commands/down.ts
-import { execa as execa3 } from "execa";
-import path6 from "path";
-import chalk3 from "chalk";
+import { execa as execa4 } from "execa";
+import path7 from "path";
+import chalk4 from "chalk";
 import ora3 from "ora";
 async function down(directory, options) {
-  const dir = path6.resolve(process.cwd(), directory);
+  const dir = path7.resolve(process.cwd(), directory);
   if (!isScaffolded(dir)) {
-    console.error(chalk3.red("\n\u274C Error: Not a Baseboards project"));
-    console.log(chalk3.gray("   Run"), chalk3.cyan("baseboards up"), chalk3.gray("to scaffold a project first."));
+    console.error(chalk4.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk4.gray("   Run"), chalk4.cyan("baseboards up"), chalk4.gray("to scaffold a project first."));
     process.exit(1);
   }
   const spinner = ora3("Stopping services...").start();
@@ -8320,12 +8412,12 @@ async function down(directory, options) {
     args.push("--volumes");
   }
   try {
-    await execa3("docker", args, {
+    await execa4("docker", args, {
       cwd: dir
     });
     spinner.succeed("Services stopped");
     if (options.volumes) {
-      console.log(chalk3.yellow("\u26A0\uFE0F  Volumes removed (database data deleted)"));
+      console.log(chalk4.yellow("\u26A0\uFE0F  Volumes removed (database data deleted)"));
     }
   } catch (error) {
     spinner.fail("Failed to stop services");
@@ -8334,14 +8426,14 @@ async function down(directory, options) {
 }
 
 // src/commands/logs.ts
-import { execa as execa4 } from "execa";
-import path7 from "path";
-import chalk4 from "chalk";
+import { execa as execa5 } from "execa";
+import path8 from "path";
+import chalk5 from "chalk";
 async function logs(directory, services, options) {
-  const dir = path7.resolve(process.cwd(), directory);
+  const dir = path8.resolve(process.cwd(), directory);
   if (!isScaffolded(dir)) {
-    console.error(chalk4.red("\n\u274C Error: Not a Baseboards project"));
-    console.log(chalk4.gray("   Run"), chalk4.cyan("baseboards up"), chalk4.gray("to scaffold a project first."));
+    console.error(chalk5.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk5.gray("   Run"), chalk5.cyan("baseboards up"), chalk5.gray("to scaffold a project first."));
     process.exit(1);
   }
   const args = ["compose", "logs"];
@@ -8358,7 +8450,7 @@ async function logs(directory, services, options) {
     args.push(...services);
   }
   try {
-    await execa4("docker", args, {
+    await execa5("docker", args, {
       cwd: dir,
       stdio: "inherit"
     });
@@ -8370,46 +8462,46 @@ async function logs(directory, services, options) {
 }
 
 // src/commands/status.ts
-import { execa as execa5 } from "execa";
-import path8 from "path";
-import chalk5 from "chalk";
+import { execa as execa6 } from "execa";
+import path9 from "path";
+import chalk6 from "chalk";
 async function status(directory) {
-  const dir = path8.resolve(process.cwd(), directory);
+  const dir = path9.resolve(process.cwd(), directory);
   if (!isScaffolded(dir)) {
-    console.error(chalk5.red("\n\u274C Error: Not a Baseboards project"));
-    console.log(chalk5.gray("   Run"), chalk5.cyan("baseboards up"), chalk5.gray("to scaffold a project first."));
+    console.error(chalk6.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk6.gray("   Run"), chalk6.cyan("baseboards up"), chalk6.gray("to scaffold a project first."));
     process.exit(1);
   }
-  console.log(chalk5.blue.bold("\n\u{1F4CA} Service Status\n"));
+  console.log(chalk6.blue.bold("\n\u{1F4CA} Service Status\n"));
   try {
-    await execa5("docker", ["compose", "ps"], {
+    await execa6("docker", ["compose", "ps"], {
       cwd: dir,
       stdio: "inherit"
     });
   } catch (error) {
-    console.error(chalk5.red("\n\u274C Failed to get status"));
+    console.error(chalk6.red("\n\u274C Failed to get status"));
     throw error;
   }
 }
 
 // src/commands/clean.ts
-import { execa as execa6 } from "execa";
-import path9 from "path";
-import chalk6 from "chalk";
+import { execa as execa7 } from "execa";
+import path10 from "path";
+import chalk7 from "chalk";
 import ora4 from "ora";
 import prompts3 from "prompts";
 async function clean(directory, options) {
-  const dir = path9.resolve(process.cwd(), directory);
+  const dir = path10.resolve(process.cwd(), directory);
   if (!isScaffolded(dir)) {
-    console.error(chalk6.red("\n\u274C Error: Not a Baseboards project"));
-    console.log(chalk6.gray("   Run"), chalk6.cyan("baseboards up"), chalk6.gray("to scaffold a project first."));
+    console.error(chalk7.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk7.gray("   Run"), chalk7.cyan("baseboards up"), chalk7.gray("to scaffold a project first."));
     process.exit(1);
   }
   if (options.hard) {
-    console.log(chalk6.yellow("\n\u26A0\uFE0F  WARNING: This will delete:"));
-    console.log(chalk6.yellow("   \u2022 All containers"));
-    console.log(chalk6.yellow("   \u2022 All volumes (database data will be lost)"));
-    console.log(chalk6.yellow("   \u2022 All images"));
+    console.log(chalk7.yellow("\n\u26A0\uFE0F  WARNING: This will delete:"));
+    console.log(chalk7.yellow("   \u2022 All containers"));
+    console.log(chalk7.yellow("   \u2022 All volumes (database data will be lost)"));
+    console.log(chalk7.yellow("   \u2022 All images"));
     const response = await prompts3({
       type: "confirm",
       name: "confirmed",
@@ -8417,33 +8509,33 @@ async function clean(directory, options) {
       initial: false
     });
     if (!response.confirmed) {
-      console.log(chalk6.gray("\nCancelled"));
+      console.log(chalk7.gray("\nCancelled"));
       return;
     }
   }
   const spinner = ora4("Cleaning up...").start();
   try {
-    await execa6("docker", ["compose", "down", "--volumes", "--remove-orphans"], {
+    await execa7("docker", ["compose", "down", "--volumes", "--remove-orphans"], {
       cwd: dir
     });
     if (options.hard) {
       try {
-        const { stdout } = await execa6("docker", ["compose", "images", "-q"], {
+        const { stdout } = await execa7("docker", ["compose", "images", "-q"], {
           cwd: dir
         });
         const imageIds = stdout.split("\n").filter(Boolean);
         if (imageIds.length > 0) {
-          await execa6("docker", ["rmi", ...imageIds]);
+          await execa7("docker", ["rmi", ...imageIds]);
         }
       } catch (e) {
       }
     }
     spinner.succeed("Cleanup complete");
     if (options.hard) {
-      console.log(chalk6.green("\n\u2728 All Docker resources removed"));
-      console.log(chalk6.gray("   Run"), chalk6.cyan("baseboards up"), chalk6.gray("to start fresh."));
+      console.log(chalk7.green("\n\u2728 All Docker resources removed"));
+      console.log(chalk7.gray("   Run"), chalk7.cyan("baseboards up"), chalk7.gray("to start fresh."));
     } else {
-      console.log(chalk6.green("\n\u2728 Containers and volumes removed"));
+      console.log(chalk7.green("\n\u2728 Containers and volumes removed"));
     }
   } catch (error) {
     spinner.fail("Cleanup failed");
@@ -8452,34 +8544,34 @@ async function clean(directory, options) {
 }
 
 // src/commands/update.ts
-import path10 from "path";
-import chalk7 from "chalk";
+import path11 from "path";
+import chalk8 from "chalk";
 async function update(directory, options) {
-  const dir = path10.resolve(process.cwd(), directory);
+  const dir = path11.resolve(process.cwd(), directory);
   if (!isScaffolded(dir)) {
-    console.error(chalk7.red("\n\u274C Error: Not a Baseboards project"));
-    console.log(chalk7.gray("   Run"), chalk7.cyan("baseboards up"), chalk7.gray("to scaffold a project first."));
+    console.error(chalk8.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk8.gray("   Run"), chalk8.cyan("baseboards up"), chalk8.gray("to scaffold a project first."));
     process.exit(1);
   }
-  console.log(chalk7.blue.bold("\n\u{1F504} Update Command\n"));
-  console.log(chalk7.yellow("\u26A0\uFE0F  This feature is coming soon!"));
-  console.log(chalk7.gray("\nFor now, to update:"));
-  console.log(chalk7.gray("1. Update the CLI:"), chalk7.cyan("npm install -g @weirdfingers/baseboards@latest"));
-  console.log(chalk7.gray("2. Pull new images:"), chalk7.cyan("docker compose pull"));
-  console.log(chalk7.gray("3. Restart:"), chalk7.cyan("baseboards down && baseboards up"));
+  console.log(chalk8.blue.bold("\n\u{1F504} Update Command\n"));
+  console.log(chalk8.yellow("\u26A0\uFE0F  This feature is coming soon!"));
+  console.log(chalk8.gray("\nFor now, to update:"));
+  console.log(chalk8.gray("1. Update the CLI:"), chalk8.cyan("npm install -g @weirdfingers/baseboards@latest"));
+  console.log(chalk8.gray("2. Pull new images:"), chalk8.cyan("docker compose pull"));
+  console.log(chalk8.gray("3. Restart:"), chalk8.cyan("baseboards down && baseboards up"));
   console.log();
 }
 
 // src/commands/upgrade.ts
-import path15 from "path";
-import chalk10 from "chalk";
+import path16 from "path";
+import chalk11 from "chalk";
 import prompts4 from "prompts";
 
 // src/utils/mode-detection.ts
 import { exec } from "child_process";
 import { promisify } from "util";
-import path11 from "path";
-import fs6 from "fs-extra";
+import path12 from "path";
+import fs7 from "fs-extra";
 var execAsync2 = promisify(exec);
 async function detectProjectMode(projectDir) {
   try {
@@ -8490,15 +8582,15 @@ async function detectProjectMode(projectDir) {
     }
   } catch {
   }
-  const modeFile = path11.join(projectDir, ".baseboards-mode");
-  if (await fs6.pathExists(modeFile)) {
-    const mode = (await fs6.readFile(modeFile, "utf-8")).trim();
+  const modeFile = path12.join(projectDir, ".baseboards-mode");
+  if (await fs7.pathExists(modeFile)) {
+    const mode = (await fs7.readFile(modeFile, "utf-8")).trim();
     if (mode === "default" || mode === "app-dev") {
       return mode;
     }
   }
-  const webNodeModules = path11.join(projectDir, "web", "node_modules");
-  if (await fs6.pathExists(webNodeModules)) {
+  const webNodeModules = path12.join(projectDir, "web", "node_modules");
+  if (await fs7.pathExists(webNodeModules)) {
     return "app-dev";
   }
   return "default";
@@ -8509,8 +8601,8 @@ import semver from "semver";
 
 // src/utils/compatibility-fetcher.ts
 var import_ajv = __toESM(require_ajv(), 1);
-import fs7 from "fs-extra";
-import path12 from "path";
+import fs8 from "fs-extra";
+import path13 from "path";
 import os from "os";
 import addFormats from "ajv-formats";
 
@@ -8573,7 +8665,7 @@ var compatibility_manifest_schema_default = {
 
 // src/utils/compatibility-fetcher.ts
 var GITHUB_REPO = "weirdfingers/boards";
-var CACHE_DIR = path12.join(os.homedir(), ".baseboards", "compatibility");
+var CACHE_DIR = path13.join(os.homedir(), ".baseboards", "compatibility");
 var ajv = new import_ajv.default({ strict: false });
 addFormats(ajv);
 var validateManifest = ajv.compile(compatibility_manifest_schema_default);
@@ -8621,31 +8713,31 @@ function getManifestUrl(version) {
 }
 async function loadFromCache(version) {
   const cachePath = getCachePath(version);
-  if (!await fs7.pathExists(cachePath)) {
+  if (!await fs8.pathExists(cachePath)) {
     return null;
   }
   try {
-    const content = await fs7.readFile(cachePath, "utf-8");
+    const content = await fs8.readFile(cachePath, "utf-8");
     const manifest = JSON.parse(content);
     if (!validateManifest(manifest)) {
-      await fs7.remove(cachePath);
+      await fs8.remove(cachePath);
       return null;
     }
     return manifest;
   } catch (error) {
-    await fs7.remove(cachePath).catch(() => {
+    await fs8.remove(cachePath).catch(() => {
     });
     return null;
   }
 }
 async function saveToCache(version, manifest) {
   const cachePath = getCachePath(version);
-  await fs7.ensureDir(CACHE_DIR);
-  await fs7.writeFile(cachePath, JSON.stringify(manifest, null, 2), "utf-8");
+  await fs8.ensureDir(CACHE_DIR);
+  await fs8.writeFile(cachePath, JSON.stringify(manifest, null, 2), "utf-8");
 }
 function getCachePath(version) {
   const cleanVersion = version.replace(/^v/, "");
-  return path12.join(CACHE_DIR, `compatibility-${cleanVersion}.json`);
+  return path13.join(CACHE_DIR, `compatibility-${cleanVersion}.json`);
 }
 
 // src/utils/compatibility-checker.ts
@@ -8697,70 +8789,70 @@ function isVersionAffected(version, affectedRange) {
 }
 
 // src/commands/upgrade-default.ts
-import path13 from "path";
-import fs8 from "fs-extra";
-import chalk8 from "chalk";
-import { execa as execa7 } from "execa";
+import path14 from "path";
+import fs9 from "fs-extra";
+import chalk9 from "chalk";
+import { execa as execa8 } from "execa";
 import ora5 from "ora";
 async function upgradeDefaultMode(projectDir, currentVersion, targetVersion) {
-  console.log(chalk8.blue(`
+  console.log(chalk9.blue(`
 \u{1F4E6} Upgrading from v${currentVersion} to v${targetVersion}
 `));
   try {
-    console.log(chalk8.gray("\u23F8\uFE0F  Stopping services..."));
+    console.log(chalk9.gray("\u23F8\uFE0F  Stopping services..."));
     await execAsync3("docker compose --env-file docker/.env down", { cwd: projectDir });
-    console.log(chalk8.gray("\u2B07\uFE0F  Pulling new backend images..."));
+    console.log(chalk9.gray("\u2B07\uFE0F  Pulling new backend images..."));
     await execAsync3("docker compose --env-file docker/.env pull api worker", { cwd: projectDir });
-    console.log(chalk8.gray("\u{1F4DD} Updating frontend dependencies..."));
+    console.log(chalk9.gray("\u{1F4DD} Updating frontend dependencies..."));
     await updateWebPackageJson(projectDir, targetVersion);
-    console.log(chalk8.gray("\u{1F528} Rebuilding frontend image (this may take a few minutes)..."));
+    console.log(chalk9.gray("\u{1F528} Rebuilding frontend image (this may take a few minutes)..."));
     await execAsync3("docker compose --env-file docker/.env build web", { cwd: projectDir });
-    console.log(chalk8.gray("\u2699\uFE0F  Updating configuration..."));
+    console.log(chalk9.gray("\u2699\uFE0F  Updating configuration..."));
     await updateEnvVersion(projectDir, targetVersion);
-    console.log(chalk8.gray("\u{1F680} Starting services..."));
+    console.log(chalk9.gray("\u{1F680} Starting services..."));
     await execAsync3("docker compose --env-file docker/.env up -d", { cwd: projectDir });
-    console.log(chalk8.gray("\u{1F3E5} Waiting for services to be healthy..."));
+    console.log(chalk9.gray("\u{1F3E5} Waiting for services to be healthy..."));
     await waitForHealth(projectDir, ["db", "cache", "api", "worker", "web"]);
-    console.log(chalk8.green(`
+    console.log(chalk9.green(`
 \u2705 Successfully upgraded to v${targetVersion}!
 `));
     printUpgradeSuccess(projectDir, targetVersion);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(chalk8.red(`
+    console.error(chalk9.red(`
 \u274C Upgrade failed: ${errorMessage}
 `));
-    console.log(chalk8.yellow("To rollback:"));
-    console.log(chalk8.gray(`  1. Edit docker/.env and set BACKEND_VERSION=${currentVersion}`));
-    console.log(chalk8.gray("  2. Run: docker compose pull"));
-    console.log(chalk8.gray("  3. Run: docker compose build web"));
-    console.log(chalk8.gray("  4. Run: docker compose up -d\n"));
+    console.log(chalk9.yellow("To rollback:"));
+    console.log(chalk9.gray(`  1. Edit docker/.env and set BACKEND_VERSION=${currentVersion}`));
+    console.log(chalk9.gray("  2. Run: docker compose pull"));
+    console.log(chalk9.gray("  3. Run: docker compose build web"));
+    console.log(chalk9.gray("  4. Run: docker compose up -d\n"));
     throw error;
   }
 }
 async function updateWebPackageJson(projectDir, version) {
-  const packageJsonPath = path13.join(projectDir, "web", "package.json");
-  const packageJson2 = await fs8.readJson(packageJsonPath);
+  const packageJsonPath = path14.join(projectDir, "web", "package.json");
+  const packageJson2 = await fs9.readJson(packageJsonPath);
   if (packageJson2.dependencies && packageJson2.dependencies["@weirdfingers/boards"]) {
     packageJson2.dependencies["@weirdfingers/boards"] = version;
   }
-  await fs8.writeJson(packageJsonPath, packageJson2, { spaces: 2 });
+  await fs9.writeJson(packageJsonPath, packageJson2, { spaces: 2 });
 }
 async function updateEnvVersion(projectDir, version) {
-  const envPath = path13.join(projectDir, "docker", ".env");
-  let content = await fs8.readFile(envPath, "utf-8");
+  const envPath = path14.join(projectDir, "docker", ".env");
+  let content = await fs9.readFile(envPath, "utf-8");
   content = content.replace(
     /^BACKEND_VERSION=.*/m,
     `BACKEND_VERSION=${version}`
   );
-  await fs8.writeFile(envPath, content, "utf-8");
+  await fs9.writeFile(envPath, content, "utf-8");
 }
 async function waitForHealth(projectDir, services) {
   const spinner = ora5("Waiting for services to be healthy...").start();
   const maxWaitMs = 12e4;
   const checkHealth = async () => {
     try {
-      const { stdout } = await execa7(
+      const { stdout } = await execa8(
         "docker",
         ["compose", "--env-file", "docker/.env", "ps", "--format", "json"],
         {
@@ -8790,106 +8882,106 @@ async function waitForHealth(projectDir, services) {
   } else {
     spinner.warn("Services taking longer than expected...");
     console.log(
-      chalk8.yellow(
+      chalk9.yellow(
         "\n\u26A0\uFE0F  Health check timeout. Services may still be starting."
       )
     );
     console.log(
-      chalk8.gray("   Run"),
-      chalk8.cyan("baseboards logs"),
-      chalk8.gray("to check progress.")
+      chalk9.gray("   Run"),
+      chalk9.cyan("baseboards logs"),
+      chalk9.gray("to check progress.")
     );
   }
 }
 function printUpgradeSuccess(projectDir, version) {
-  console.log(chalk8.gray("   Your Baseboards installation has been upgraded."));
-  console.log(chalk8.gray("   All services are running and healthy.\n"));
-  console.log(chalk8.gray("Next steps:"));
-  console.log(chalk8.gray(`  \u2022 Check release notes: https://github.com/weirdfingers/boards/releases/tag/v${version}`));
-  console.log(chalk8.gray(`  \u2022 View logs: baseboards logs ${path13.basename(projectDir)}`));
-  console.log(chalk8.gray(`  \u2022 Check status: baseboards status ${path13.basename(projectDir)}
+  console.log(chalk9.gray("   Your Baseboards installation has been upgraded."));
+  console.log(chalk9.gray("   All services are running and healthy.\n"));
+  console.log(chalk9.gray("Next steps:"));
+  console.log(chalk9.gray(`  \u2022 Check release notes: https://github.com/weirdfingers/boards/releases/tag/v${version}`));
+  console.log(chalk9.gray(`  \u2022 View logs: baseboards logs ${path14.basename(projectDir)}`));
+  console.log(chalk9.gray(`  \u2022 Check status: baseboards status ${path14.basename(projectDir)}
 `));
 }
 async function execAsync3(command, options) {
   const [cmd, ...args] = command.split(" ");
-  return execa7(cmd, args, options);
+  return execa8(cmd, args, options);
 }
 
 // src/commands/upgrade-app-dev.ts
-import path14 from "path";
-import fs9 from "fs-extra";
-import chalk9 from "chalk";
-import { execa as execa8 } from "execa";
+import path15 from "path";
+import fs10 from "fs-extra";
+import chalk10 from "chalk";
+import { execa as execa9 } from "execa";
 import ora6 from "ora";
 async function upgradeAppDevMode(projectDir, currentVersion, targetVersion) {
-  console.log(chalk9.blue(`
+  console.log(chalk10.blue(`
 \u{1F4E6} Upgrading backend from v${currentVersion} to v${targetVersion}
 `));
   try {
-    console.log(chalk9.gray("\u23F8\uFE0F  Stopping backend services..."));
+    console.log(chalk10.gray("\u23F8\uFE0F  Stopping backend services..."));
     await execAsync("docker compose --env-file docker/.env down", { cwd: projectDir });
-    console.log(chalk9.gray("\u2B07\uFE0F  Pulling new backend images..."));
+    console.log(chalk10.gray("\u2B07\uFE0F  Pulling new backend images..."));
     await execAsync("docker compose --env-file docker/.env pull api worker", { cwd: projectDir });
-    console.log(chalk9.gray("\u2699\uFE0F  Updating configuration..."));
+    console.log(chalk10.gray("\u2699\uFE0F  Updating configuration..."));
     await updateEnvVersion2(projectDir, targetVersion);
-    console.log(chalk9.gray("\u{1F680} Starting backend services..."));
+    console.log(chalk10.gray("\u{1F680} Starting backend services..."));
     await execAsync("docker compose --env-file docker/.env up -d db cache api worker", { cwd: projectDir });
-    console.log(chalk9.gray("\u{1F3E5} Waiting for backend to be healthy..."));
+    console.log(chalk10.gray("\u{1F3E5} Waiting for backend to be healthy..."));
     await waitForHealth2(projectDir, ["db", "cache", "api", "worker"]);
-    console.log(chalk9.green(`
+    console.log(chalk10.green(`
 \u2705 Backend upgraded to v${targetVersion}!
 `));
     await printAppDevUpgradeInstructions(projectDir, currentVersion, targetVersion);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(chalk9.red(`
+    console.error(chalk10.red(`
 \u274C Upgrade failed: ${errorMessage}
 `));
-    console.log(chalk9.yellow("To rollback:"));
-    console.log(chalk9.gray(`  1. Edit docker/.env and set BACKEND_VERSION=${currentVersion}`));
-    console.log(chalk9.gray("  2. Run: docker compose --env-file docker/.env pull"));
-    console.log(chalk9.gray("  3. Run: docker compose --env-file docker/.env up -d db cache api worker\n"));
+    console.log(chalk10.yellow("To rollback:"));
+    console.log(chalk10.gray(`  1. Edit docker/.env and set BACKEND_VERSION=${currentVersion}`));
+    console.log(chalk10.gray("  2. Run: docker compose --env-file docker/.env pull"));
+    console.log(chalk10.gray("  3. Run: docker compose --env-file docker/.env up -d db cache api worker\n"));
     throw error;
   }
 }
 async function updateEnvVersion2(projectDir, version) {
-  const envPath = path14.join(projectDir, "docker", ".env");
-  let content = await fs9.readFile(envPath, "utf-8");
+  const envPath = path15.join(projectDir, "docker", ".env");
+  let content = await fs10.readFile(envPath, "utf-8");
   content = content.replace(
     /^BACKEND_VERSION=.*/m,
     `BACKEND_VERSION=${version}`
   );
-  await fs9.writeFile(envPath, content, "utf-8");
+  await fs10.writeFile(envPath, content, "utf-8");
 }
 async function printAppDevUpgradeInstructions(projectDir, oldVersion, newVersion) {
-  const webDir = path14.join(projectDir, "web");
+  const webDir = path15.join(projectDir, "web");
   const packageManager = await detectPackageManager(webDir);
   const updateCommand = packageManager === "npm" ? `npm install @weirdfingers/boards@${newVersion}` : packageManager === "yarn" ? `yarn upgrade @weirdfingers/boards@${newVersion}` : packageManager === "bun" ? `bun update @weirdfingers/boards@${newVersion}` : `pnpm update @weirdfingers/boards@${newVersion}`;
-  console.log(chalk9.yellow("\u26A0\uFE0F  Frontend requires manual upgrade:\n"));
-  console.log(chalk9.gray("   1. Stop your dev server (Ctrl+C if running)\n"));
-  console.log(chalk9.gray("   2. Update the frontend package:\n"));
-  console.log(chalk9.cyan(`      cd ${path14.basename(projectDir)}/web`));
-  console.log(chalk9.cyan(`      ${updateCommand}
+  console.log(chalk10.yellow("\u26A0\uFE0F  Frontend requires manual upgrade:\n"));
+  console.log(chalk10.gray("   1. Stop your dev server (Ctrl+C if running)\n"));
+  console.log(chalk10.gray("   2. Update the frontend package:\n"));
+  console.log(chalk10.cyan(`      cd ${path15.basename(projectDir)}/web`));
+  console.log(chalk10.cyan(`      ${updateCommand}
 `));
-  console.log(chalk9.gray("   3. Check for breaking changes:\n"));
-  console.log(chalk9.gray(`      https://github.com/weirdfingers/boards/releases/tag/v${newVersion}
+  console.log(chalk10.gray("   3. Check for breaking changes:\n"));
+  console.log(chalk10.gray(`      https://github.com/weirdfingers/boards/releases/tag/v${newVersion}
 `));
-  console.log(chalk9.gray("   4. Restart your dev server:\n"));
-  console.log(chalk9.cyan(`      ${packageManager} dev
+  console.log(chalk10.gray("   4. Restart your dev server:\n"));
+  console.log(chalk10.cyan(`      ${packageManager} dev
 `));
   try {
     const { stdout } = await execAsync("git status --porcelain", { cwd: webDir });
     if (stdout.trim()) {
-      console.log(chalk9.yellow("\u26A0\uFE0F  You have uncommitted changes in web/"));
-      console.log(chalk9.gray("   Consider committing before updating dependencies.\n"));
+      console.log(chalk10.yellow("\u26A0\uFE0F  You have uncommitted changes in web/"));
+      console.log(chalk10.gray("   Consider committing before updating dependencies.\n"));
     }
   } catch (error) {
-    const gitDir = path14.join(webDir, ".git");
-    if (!fs9.existsSync(gitDir)) {
-      console.log(chalk9.gray("   Skipping git status check: web/ is not a git repository."));
+    const gitDir = path15.join(webDir, ".git");
+    if (!fs10.existsSync(gitDir)) {
+      console.log(chalk10.gray("   Skipping git status check: web/ is not a git repository."));
     } else {
       console.log(
-        chalk9.gray(
+        chalk10.gray(
           "   Skipping git status check: git is not available or an error occurred while checking repository status."
         )
       );
@@ -8901,7 +8993,7 @@ async function waitForHealth2(projectDir, services) {
   const maxWaitMs = 12e4;
   const checkHealth = async () => {
     try {
-      const { stdout } = await execa8(
+      const { stdout } = await execa9(
         "docker",
         ["compose", "--env-file", "docker/.env", "ps", "--format", "json"],
         {
@@ -8931,61 +9023,61 @@ async function waitForHealth2(projectDir, services) {
   } else {
     spinner.warn("Services taking longer than expected...");
     console.log(
-      chalk9.yellow(
+      chalk10.yellow(
         "\n\u26A0\uFE0F  Health check timeout. Services may still be starting."
       )
     );
     console.log(
-      chalk9.gray("   Run"),
-      chalk9.cyan("baseboards logs"),
-      chalk9.gray("to check progress.")
+      chalk10.gray("   Run"),
+      chalk10.cyan("baseboards logs"),
+      chalk10.gray("to check progress.")
     );
   }
 }
 
 // src/commands/upgrade.ts
 async function upgrade(directory, options) {
-  const dir = path15.resolve(process.cwd(), directory);
+  const dir = path16.resolve(process.cwd(), directory);
   if (!isScaffolded(dir)) {
-    console.error(chalk10.red("\n\u274C Error: Not a Baseboards project"));
-    console.log(chalk10.gray("   Run"), chalk10.cyan("baseboards up"), chalk10.gray("to scaffold a project first."));
+    console.error(chalk11.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk11.gray("   Run"), chalk11.cyan("baseboards up"), chalk11.gray("to scaffold a project first."));
     process.exit(1);
   }
   const currentVersion = await getCurrentVersion(dir);
   if (!currentVersion) {
-    console.error(chalk10.red("\n\u274C Error: Could not determine current version"));
-    console.log(chalk10.gray("   Check docker/.env for VERSION field"));
+    console.error(chalk11.red("\n\u274C Error: Could not determine current version"));
+    console.log(chalk11.gray("   Check docker/.env for VERSION field"));
     process.exit(1);
   }
   const targetVersion = options.version || await getLatestVersion();
   if (currentVersion === targetVersion) {
-    console.log(chalk10.green(`
+    console.log(chalk11.green(`
 \u2705 Already at v${targetVersion}`));
     return;
   }
   const compatCheck = await checkCompatibility(currentVersion, targetVersion);
   const mode = await detectProjectMode(dir);
-  console.log(chalk10.blue("\u{1F4CB} Upgrade Plan:\n"));
-  console.log(chalk10.gray(`   Current version: ${currentVersion}`));
-  console.log(chalk10.gray(`   Target version:  ${targetVersion}`));
-  console.log(chalk10.gray(`   Project mode:    ${mode}`));
+  console.log(chalk11.blue("\u{1F4CB} Upgrade Plan:\n"));
+  console.log(chalk11.gray(`   Current version: ${currentVersion}`));
+  console.log(chalk11.gray(`   Target version:  ${targetVersion}`));
+  console.log(chalk11.gray(`   Project mode:    ${mode}`));
   console.log("");
   if (mode === "default") {
-    console.log(chalk10.gray("   Steps:"));
-    console.log(chalk10.gray("   1. Stop all services"));
-    console.log(chalk10.gray("   2. Pull new backend images"));
-    console.log(chalk10.gray("   3. Update web/package.json"));
-    console.log(chalk10.gray("   4. Rebuild frontend Docker image"));
-    console.log(chalk10.gray("   5. Update docker/.env"));
-    console.log(chalk10.gray("   6. Start services"));
-    console.log(chalk10.gray("   7. Wait for health checks"));
+    console.log(chalk11.gray("   Steps:"));
+    console.log(chalk11.gray("   1. Stop all services"));
+    console.log(chalk11.gray("   2. Pull new backend images"));
+    console.log(chalk11.gray("   3. Update web/package.json"));
+    console.log(chalk11.gray("   4. Rebuild frontend Docker image"));
+    console.log(chalk11.gray("   5. Update docker/.env"));
+    console.log(chalk11.gray("   6. Start services"));
+    console.log(chalk11.gray("   7. Wait for health checks"));
   } else {
-    console.log(chalk10.gray("   Steps:"));
-    console.log(chalk10.gray("   1. Stop backend services"));
-    console.log(chalk10.gray("   2. Pull new backend images"));
-    console.log(chalk10.gray("   3. Update docker/.env"));
-    console.log(chalk10.gray("   4. Start backend services"));
-    console.log(chalk10.gray("   5. Print manual frontend update instructions"));
+    console.log(chalk11.gray("   Steps:"));
+    console.log(chalk11.gray("   1. Stop backend services"));
+    console.log(chalk11.gray("   2. Pull new backend images"));
+    console.log(chalk11.gray("   3. Update docker/.env"));
+    console.log(chalk11.gray("   4. Start backend services"));
+    console.log(chalk11.gray("   5. Print manual frontend update instructions"));
   }
   console.log("");
   if (compatCheck.warnings.length > 0) {
@@ -8993,18 +9085,18 @@ async function upgrade(directory, options) {
     console.log("");
   }
   if (compatCheck.requiredActions.length > 0) {
-    console.log(chalk10.yellow("\u26A0\uFE0F  Required manual actions:"));
+    console.log(chalk11.yellow("\u26A0\uFE0F  Required manual actions:"));
     compatCheck.requiredActions.forEach((action) => {
-      console.log(chalk10.gray(`   \u2022 ${action}`));
+      console.log(chalk11.gray(`   \u2022 ${action}`));
     });
     console.log("");
   }
   if (options.dryRun) {
-    console.log(chalk10.blue("\u{1F50D} Dry run complete - no changes made\n"));
+    console.log(chalk11.blue("\u{1F50D} Dry run complete - no changes made\n"));
     return;
   }
   if (options.force && compatCheck.breaking) {
-    console.log(chalk10.yellow("\u26A0\uFE0F  --force flag used: skipping confirmation despite breaking changes\n"));
+    console.log(chalk11.yellow("\u26A0\uFE0F  --force flag used: skipping confirmation despite breaking changes\n"));
   }
   if (!options.force && compatCheck.breaking) {
     const { proceed } = await prompts4({
@@ -9014,7 +9106,7 @@ async function upgrade(directory, options) {
       initial: false
     });
     if (!proceed) {
-      console.log(chalk10.gray("\nUpgrade cancelled\n"));
+      console.log(chalk11.gray("\nUpgrade cancelled\n"));
       return;
     }
   }
@@ -9034,104 +9126,104 @@ async function getLatestVersion() {
 }
 
 // src/commands/doctor.ts
-import path16 from "path";
-import fs10 from "fs-extra";
-import chalk11 from "chalk";
+import path17 from "path";
+import fs11 from "fs-extra";
+import chalk12 from "chalk";
 async function doctor(directory) {
-  const dir = path16.resolve(process.cwd(), directory);
-  console.log(chalk11.blue.bold("\n\u{1FA7A} Baseboards Diagnostics\n"));
-  console.log(chalk11.cyan("CLI Version:"), getCliVersion());
-  console.log(chalk11.cyan("\n\u{1F4CB} Prerequisites:"));
+  const dir = path17.resolve(process.cwd(), directory);
+  console.log(chalk12.blue.bold("\n\u{1FA7A} Baseboards Diagnostics\n"));
+  console.log(chalk12.cyan("CLI Version:"), getCliVersion());
+  console.log(chalk12.cyan("\n\u{1F4CB} Prerequisites:"));
   const prereqs = await checkPrerequisites();
   console.log(
-    chalk11.gray("  Node.js:"),
-    prereqs.node.installed ? prereqs.node.satisfies ? chalk11.green(`\u2713 v${prereqs.node.version}`) : chalk11.yellow(`\u26A0\uFE0F  v${prereqs.node.version} (need v20+)`) : chalk11.red("\u2717 Not installed")
+    chalk12.gray("  Node.js:"),
+    prereqs.node.installed ? prereqs.node.satisfies ? chalk12.green(`\u2713 v${prereqs.node.version}`) : chalk12.yellow(`\u26A0\uFE0F  v${prereqs.node.version} (need v20+)`) : chalk12.red("\u2717 Not installed")
   );
   console.log(
-    chalk11.gray("  Docker:"),
-    prereqs.docker.installed ? chalk11.green(`\u2713 v${prereqs.docker.version}`) : chalk11.red("\u2717 Not installed")
+    chalk12.gray("  Docker:"),
+    prereqs.docker.installed ? chalk12.green(`\u2713 v${prereqs.docker.version}`) : chalk12.red("\u2717 Not installed")
   );
   if (prereqs.docker.composeVersion) {
     console.log(
-      chalk11.gray("  Docker Compose:"),
-      chalk11.green(`\u2713 v${prereqs.docker.composeVersion}`)
+      chalk12.gray("  Docker Compose:"),
+      chalk12.green(`\u2713 v${prereqs.docker.composeVersion}`)
     );
   } else if (prereqs.docker.installed) {
-    console.log(chalk11.gray("  Docker Compose:"), chalk11.red("\u2717 Not available"));
+    console.log(chalk12.gray("  Docker Compose:"), chalk12.red("\u2717 Not available"));
   }
-  console.log(chalk11.gray("  Platform:"), prereqs.platform.name);
+  console.log(chalk12.gray("  Platform:"), prereqs.platform.name);
   if (prereqs.platform.isWSL) {
-    console.log(chalk11.gray("  WSL:"), chalk11.blue("\u2713 Detected"));
+    console.log(chalk12.gray("  WSL:"), chalk12.blue("\u2713 Detected"));
   }
-  console.log(chalk11.cyan("\n\u{1F4C2} Project:"));
+  console.log(chalk12.cyan("\n\u{1F4C2} Project:"));
   const scaffolded = isScaffolded(dir);
   console.log(
-    chalk11.gray("  Scaffolded:"),
-    scaffolded ? chalk11.green("\u2713 Yes") : chalk11.yellow("\u2717 No")
+    chalk12.gray("  Scaffolded:"),
+    scaffolded ? chalk12.green("\u2713 Yes") : chalk12.yellow("\u2717 No")
   );
   if (scaffolded) {
-    console.log(chalk11.gray("  Directory:"), dir);
-    const webPkg = path16.join(dir, "web/package.json");
-    const apiPkg = path16.join(dir, "api/pyproject.toml");
-    const composeFile = path16.join(dir, "compose.yaml");
+    console.log(chalk12.gray("  Directory:"), dir);
+    const webPkg = path17.join(dir, "web/package.json");
+    const apiPkg = path17.join(dir, "api/pyproject.toml");
+    const composeFile = path17.join(dir, "compose.yaml");
     console.log(
-      chalk11.gray("  Web package:"),
-      fs10.existsSync(webPkg) ? chalk11.green("\u2713") : chalk11.red("\u2717")
+      chalk12.gray("  Web package:"),
+      fs11.existsSync(webPkg) ? chalk12.green("\u2713") : chalk12.red("\u2717")
     );
     console.log(
-      chalk11.gray("  API package:"),
-      fs10.existsSync(apiPkg) ? chalk11.green("\u2713") : chalk11.red("\u2717")
+      chalk12.gray("  API package:"),
+      fs11.existsSync(apiPkg) ? chalk12.green("\u2713") : chalk12.red("\u2717")
     );
     console.log(
-      chalk11.gray("  Compose file:"),
-      fs10.existsSync(composeFile) ? chalk11.green("\u2713") : chalk11.red("\u2717")
+      chalk12.gray("  Compose file:"),
+      fs11.existsSync(composeFile) ? chalk12.green("\u2713") : chalk12.red("\u2717")
     );
-    console.log(chalk11.cyan("\n\u{1F510} Environment:"));
-    const webEnv = path16.join(dir, "web/.env");
-    const apiEnv = path16.join(dir, "api/.env");
-    const dockerEnv = path16.join(dir, "docker/.env");
+    console.log(chalk12.cyan("\n\u{1F510} Environment:"));
+    const webEnv = path17.join(dir, "web/.env");
+    const apiEnv = path17.join(dir, "api/.env");
+    const dockerEnv = path17.join(dir, "docker/.env");
     console.log(
-      chalk11.gray("  Web .env:"),
-      fs10.existsSync(webEnv) ? chalk11.green("\u2713") : chalk11.yellow("\u2717 Missing")
+      chalk12.gray("  Web .env:"),
+      fs11.existsSync(webEnv) ? chalk12.green("\u2713") : chalk12.yellow("\u2717 Missing")
     );
     console.log(
-      chalk11.gray("  API .env:"),
-      fs10.existsSync(apiEnv) ? chalk11.green("\u2713") : chalk11.yellow("\u2717 Missing")
+      chalk12.gray("  API .env:"),
+      fs11.existsSync(apiEnv) ? chalk12.green("\u2713") : chalk12.yellow("\u2717 Missing")
     );
     console.log(
-      chalk11.gray("  Docker .env:"),
-      fs10.existsSync(dockerEnv) ? chalk11.green("\u2713") : chalk11.yellow("\u2717 Missing")
+      chalk12.gray("  Docker .env:"),
+      fs11.existsSync(dockerEnv) ? chalk12.green("\u2713") : chalk12.yellow("\u2717 Missing")
     );
-    if (fs10.existsSync(apiEnv)) {
+    if (fs11.existsSync(apiEnv)) {
       const missingKeys = detectMissingProviderKeys(apiEnv);
       if (missingKeys.length > 0) {
         console.log(
-          chalk11.gray("  Provider keys:"),
-          chalk11.yellow(`\u26A0\uFE0F  ${missingKeys.length} missing`)
+          chalk12.gray("  Provider keys:"),
+          chalk12.yellow(`\u26A0\uFE0F  ${missingKeys.length} missing`)
         );
-        console.log(chalk11.gray("    Missing:"), missingKeys.map((k) => chalk11.cyan(k)).join(", "));
+        console.log(chalk12.gray("    Missing:"), missingKeys.map((k) => chalk12.cyan(k)).join(", "));
       } else {
-        console.log(chalk11.gray("  Provider keys:"), chalk11.green("\u2713 Configured"));
+        console.log(chalk12.gray("  Provider keys:"), chalk12.green("\u2713 Configured"));
       }
     }
-    console.log(chalk11.cyan("\n\u2699\uFE0F  Configuration:"));
-    const generatorsYaml = path16.join(dir, "api/config/generators.yaml");
-    const storageYaml = path16.join(dir, "api/config/storage_config.yaml");
+    console.log(chalk12.cyan("\n\u2699\uFE0F  Configuration:"));
+    const generatorsYaml = path17.join(dir, "api/config/generators.yaml");
+    const storageYaml = path17.join(dir, "api/config/storage_config.yaml");
     console.log(
-      chalk11.gray("  generators.yaml:"),
-      fs10.existsSync(generatorsYaml) ? chalk11.green("\u2713") : chalk11.yellow("\u2717 Missing")
+      chalk12.gray("  generators.yaml:"),
+      fs11.existsSync(generatorsYaml) ? chalk12.green("\u2713") : chalk12.yellow("\u2717 Missing")
     );
     console.log(
-      chalk11.gray("  storage_config.yaml:"),
-      fs10.existsSync(storageYaml) ? chalk11.green("\u2713") : chalk11.yellow("\u2717 Missing")
+      chalk12.gray("  storage_config.yaml:"),
+      fs11.existsSync(storageYaml) ? chalk12.green("\u2713") : chalk12.yellow("\u2717 Missing")
     );
-    const storageDir = path16.join(dir, "data/storage");
+    const storageDir = path17.join(dir, "data/storage");
     console.log(
-      chalk11.gray("  Storage directory:"),
-      fs10.existsSync(storageDir) ? chalk11.green("\u2713") : chalk11.yellow("\u2717 Missing")
+      chalk12.gray("  Storage directory:"),
+      fs11.existsSync(storageDir) ? chalk12.green("\u2713") : chalk12.yellow("\u2717 Missing")
     );
   }
-  console.log(chalk11.cyan("\n\u{1F4A1} Recommendations:"));
+  console.log(chalk12.cyan("\n\u{1F4A1} Recommendations:"));
   const recommendations = [];
   if (!prereqs.node.satisfies) {
     recommendations.push("Upgrade Node.js to v20 or higher");
@@ -9142,18 +9234,18 @@ async function doctor(directory) {
     recommendations.push("Update Docker to get Compose v2");
   }
   if (!scaffolded) {
-    recommendations.push("Run " + chalk11.cyan("baseboards up") + " to scaffold a project");
+    recommendations.push("Run " + chalk12.cyan("baseboards up") + " to scaffold a project");
   }
   if (recommendations.length === 0) {
-    console.log(chalk11.green("  \u2713 Everything looks good!"));
+    console.log(chalk12.green("  \u2713 Everything looks good!"));
   } else {
-    recommendations.forEach((rec) => console.log(chalk11.yellow("  \u2022"), rec));
+    recommendations.forEach((rec) => console.log(chalk12.yellow("  \u2022"), rec));
   }
   console.log();
 }
 
 // src/commands/templates.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 function formatSize(bytes) {
   if (bytes < 1024) {
     return `${bytes} B`;
@@ -9164,22 +9256,22 @@ function formatSize(bytes) {
   }
 }
 function displayTemplate(template, isRecommended) {
-  const name = chalk12.bold(template.name);
-  const recommended = isRecommended ? chalk12.cyan(" (recommended)") : "";
+  const name = chalk13.bold(template.name);
+  const recommended = isRecommended ? chalk13.cyan(" (recommended)") : "";
   console.log(`
 ${name}${recommended}`);
   console.log(`  ${template.description}`);
   const frameworks = template.frameworks.join(", ");
-  console.log(`  ${chalk12.gray("Frameworks:")} ${frameworks}`);
+  console.log(`  ${chalk13.gray("Frameworks:")} ${frameworks}`);
   const features = template.features.join(", ");
-  console.log(`  ${chalk12.gray("Features:")} ${features}`);
+  console.log(`  ${chalk13.gray("Features:")} ${features}`);
   const size = formatSize(template.size);
-  console.log(`  ${chalk12.gray("Size:")} ${size}`);
+  console.log(`  ${chalk13.gray("Size:")} ${size}`);
 }
 async function templates(options) {
   try {
     if (options.refresh) {
-      console.log(chalk12.blue("\u{1F504} Clearing cache and refreshing templates...\n"));
+      console.log(chalk13.blue("\u{1F504} Clearing cache and refreshing templates...\n"));
       await clearCache();
     }
     const version = options.version || getCliVersion();
@@ -9189,24 +9281,24 @@ async function templates(options) {
     } catch (error) {
       if (error.message.includes("Failed to fetch")) {
         console.error(
-          chalk12.red("\n\u274C Network error:"),
+          chalk13.red("\n\u274C Network error:"),
           "Unable to fetch template list"
         );
         console.log(
-          chalk12.yellow("\n\u{1F4A1} Tip:"),
+          chalk13.yellow("\n\u{1F4A1} Tip:"),
           "Check your internet connection or try again later"
         );
         process.exit(1);
       }
       if (error.message.includes("not found")) {
         console.error(
-          chalk12.red("\n\u274C Version not found:"),
+          chalk13.red("\n\u274C Version not found:"),
           `Version ${version} does not exist`
         );
         console.log(
-          chalk12.yellow("\n\u{1F4A1} Tip:"),
+          chalk13.yellow("\n\u{1F4A1} Tip:"),
           "Check available versions at:",
-          chalk12.cyan("https://github.com/weirdfingers/boards/releases")
+          chalk13.cyan("https://github.com/weirdfingers/boards/releases")
         );
         process.exit(1);
       }
@@ -9214,13 +9306,13 @@ async function templates(options) {
     }
     if (!manifest.templates || manifest.templates.length === 0) {
       console.log(
-        chalk12.yellow("\n\u26A0\uFE0F  No templates available for version"),
+        chalk13.yellow("\n\u26A0\uFE0F  No templates available for version"),
         manifest.version
       );
       process.exit(0);
     }
     console.log(
-      chalk12.blue.bold(`
+      chalk13.blue.bold(`
 \u{1F4E6} Available templates for v${manifest.version}:`)
     );
     for (const template of manifest.templates) {
@@ -9229,10 +9321,10 @@ async function templates(options) {
     }
     console.log();
   } catch (error) {
-    console.error(chalk12.red("\n\u274C Error:"), error.message || "Unknown error");
+    console.error(chalk13.red("\n\u274C Error:"), error.message || "Unknown error");
     console.error(
-      chalk12.yellow("\n\u{1F4A1} Try running:"),
-      chalk12.cyan("baseboards doctor")
+      chalk13.yellow("\n\u{1F4A1} Try running:"),
+      chalk13.cyan("baseboards doctor")
     );
     process.exit(1);
   }
@@ -9277,18 +9369,18 @@ try {
     process.exit(1);
   }
   const err = error;
-  console.error(chalk13.red("\n\u274C Error:"), err.message || "Unknown error");
+  console.error(chalk14.red("\n\u274C Error:"), err.message || "Unknown error");
   if (err.stderr) {
-    console.error(chalk13.gray("\nDetails:"));
-    console.error(chalk13.gray(err.stderr));
+    console.error(chalk14.gray("\nDetails:"));
+    console.error(chalk14.gray(err.stderr));
   }
   console.error(
-    chalk13.yellow("\n\u{1F4A1} Try running:"),
-    chalk13.cyan("baseboards doctor")
+    chalk14.yellow("\n\u{1F4A1} Try running:"),
+    chalk14.cyan("baseboards doctor")
   );
   console.error(
-    chalk13.yellow("\u{1F4D6} Documentation:"),
-    chalk13.cyan("https://baseboards.dev/docs")
+    chalk14.yellow("\u{1F4D6} Documentation:"),
+    chalk14.cyan("https://baseboards.dev/docs")
   );
   process.exit(1);
 }