feat: add automatic Compact compiler version update

Users with outdated Compact versions now get prompted to update
automatically instead of hitting cryptic compilation errors.

New CompactUpdater utility:
- Detects version mismatches before project creation
- Prompts user with clear explanation of issue
- Updates Compact automatically with progress feedback
- Verifies update success and re-checks requirements

User Experience:
- Clear version mismatch messaging (e.g., "requires 0.23.0+, found 0.15.0")
- Optional automatic update (user can decline)
- Real-time progress during update
- Manual update instructions if declined

Implementation:
- New: src/utils/compact-updater.ts (automatic update logic)
- Modified: src/create-app.ts (integrated auto-update flow)
- Modified: src/utils/requirement-checker.ts (version checking)
- Modified: src/utils/templates.ts (version requirements)
- Modified: README.md (documented auto-update feature)

Resolves: Issue reported by Linux user with Compact 0.15.0
when Counter template requires 0.23.0+

Author: Olanetsoft

README.md

@@ -36,12 +36,16 @@ create-mn-app my-app
 
 ## Features
 
-- Interactive project setup with template selection
-- Auto-detects package manager (npm/yarn/pnpm/bun)
-- Environment health checks
-- TypeScript with hot reloading
-- Pre-configured Compact contracts
-- Secure wallet generation
+- **Interactive project setup** with template selection
+- **Auto-detects package manager** (npm/yarn/pnpm/bun)
+- **Smart dependency management**:
+  - Checks Node.js, Docker, and Compact compiler versions
+  - **Automatic Compact compiler updates** when version mismatch detected
+  - Prompts user before updating with clear explanations
+- **TypeScript** with hot reloading
+- **Pre-configured Compact contracts**
+- **Secure wallet generation**
+- **Environment health checks**
 
 ## Quick Start
 
@@ -95,10 +99,13 @@ npm install
 
 ## Requirements
 
-- Node.js 22+
-- Docker (for proof server)
-- npm/yarn/pnpm/bun
-- Compact Compiler (for Counter template - auto-guided installation)
+- **Node.js 22+** - Required for all templates
+- **Docker** - Required for running the proof server
+- **npm/yarn/pnpm/bun** - Package manager (auto-detected)
+- **Compact Compiler 0.23.0+** - Required for Counter template
+  - **Auto-update available**: If you have an older version, the CLI will offer to update it automatically
+  - Version compatibility checked before project creation
+  - Manual installation: See [Compact releases](https://github.com/midnightntwrk/compact/releases/latest)
 
 ## CLI Options
 

src/create-app.ts

@@ -39,6 +39,7 @@ import {
   getTemplate,
   isValidTemplate,
 } from "./utils/templates.js";
+import { CompactUpdater } from "./utils/compact-updater.js";
 
 export interface CreateAppOptions {
   template?: string;
@@ -362,16 +363,66 @@ async function createRemoteTemplate(
     checks.push(RequirementChecker.checkDocker());
 
     if (template.requiresCompactCompiler) {
-      checks.push(RequirementChecker.checkCompactCompiler());
+      checks.push(
+        RequirementChecker.checkCompactCompiler(template.compactVersion)
+      );
     }
 
     const allPassed = RequirementChecker.displayResults(checks);
 
     if (!allPassed) {
-      console.log(
-        chalk.yellow("\n⚠ Please install missing requirements and try again.\n")
-      );
-      process.exit(1);
+      // Check if the issue is Compact version mismatch
+      if (template.requiresCompactCompiler && template.compactVersion) {
+        const currentVersion = CompactUpdater.getCurrentVersion();
+        if (
+          currentVersion &&
+          CompactUpdater.needsUpdate(currentVersion, template.compactVersion)
+        ) {
+          // Offer to update Compact automatically
+          const updateSuccess = await CompactUpdater.handleVersionMismatch(
+            currentVersion,
+            template.compactVersion
+          );
+
+          if (updateSuccess) {
+            // Re-check requirements after update
+            console.log(chalk.cyan("\n[✓] Re-checking requirements...\n"));
+            const recheckPassed = RequirementChecker.displayResults([
+              RequirementChecker.checkCompactCompiler(template.compactVersion),
+            ]);
+
+            if (!recheckPassed) {
+              console.log(
+                chalk.red(
+                  "\n❌ Requirements still not met after update. Please check manually.\n"
+                )
+              );
+              process.exit(1);
+            }
+          } else {
+            console.log(
+              chalk.yellow(
+                "\n⚠ Please update Compact manually and try again.\n"
+              )
+            );
+            process.exit(1);
+          }
+        } else {
+          console.log(
+            chalk.yellow(
+              "\n⚠ Please install missing requirements and try again.\n"
+            )
+          );
+          process.exit(1);
+        }
+      } else {
+        console.log(
+          chalk.yellow(
+            "\n⚠ Please install missing requirements and try again.\n"
+          )
+        );
+        process.exit(1);
+      }
     }
   }
 

src/utils/compact-updater.ts

@@ -0,0 +1,209 @@
+// This file is part of create-mn-app.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { execSync, spawn } from "child_process";
+import chalk from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+
+export class CompactUpdater {
+  /**
+   * Check if Compact needs updating
+   */
+  static needsUpdate(currentVersion: string, requiredVersion: string): boolean {
+    const current = currentVersion.split(".").map(Number);
+    const required = requiredVersion.split(".").map(Number);
+
+    for (let i = 0; i < Math.max(current.length, required.length); i++) {
+      const curr = current[i] || 0;
+      const req = required[i] || 0;
+
+      if (curr < req) return true;
+      if (curr > req) return false;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get the current installed Compact version
+   */
+  static getCurrentVersion(): string | null {
+    try {
+      const versionOutput = execSync("compact compile --version", {
+        encoding: "utf-8",
+      }).trim();
+
+      const versionMatch = versionOutput.match(/(\d+\.\d+\.\d+)/);
+      return versionMatch ? versionMatch[1] : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Prompt user to update Compact compiler
+   */
+  static async promptUpdate(
+    currentVersion: string,
+    requiredVersion: string
+  ): Promise<boolean> {
+    console.log(
+      chalk.yellow(
+        `\n⚠️  Your Compact compiler version ${chalk.bold(
+          currentVersion
+        )} is outdated.`
+      )
+    );
+    console.log(
+      chalk.yellow(
+        `   This template requires version ${chalk.bold(
+          requiredVersion
+        )}+ to work correctly.\n`
+      )
+    );
+
+    const response = await prompts({
+      type: "confirm",
+      name: "shouldUpdate",
+      message: `Would you like to update Compact compiler now?`,
+      initial: true,
+    });
+
+    return response.shouldUpdate;
+  }
+
+  /**
+   * Update Compact compiler to the latest version
+   */
+  static async updateCompact(): Promise<boolean> {
+    const spinner = ora({
+      text: "Updating Compact compiler to latest version...",
+      color: "cyan",
+    }).start();
+
+    return new Promise((resolve) => {
+      const installScript =
+        "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/midnightntwrk/compact/releases/latest/download/compact-installer.sh | sh";
+
+      const updateProcess = spawn("sh", ["-c", installScript], {
+        stdio: ["inherit", "pipe", "pipe"],
+      });
+
+      let hasError = false;
+
+      updateProcess.stdout?.on("data", (data) => {
+        const output = data.toString().trim();
+        if (output) {
+          spinner.text = `Updating Compact compiler... ${chalk.gray(
+            output.slice(0, 60)
+          )}`;
+        }
+      });
+
+      updateProcess.stderr?.on("data", (data) => {
+        const error = data.toString().trim();
+        if (error && !error.includes("Downloading")) {
+          hasError = true;
+          spinner.fail(
+            `Failed to update Compact compiler: ${chalk.red(error)}`
+          );
+        }
+      });
+
+      updateProcess.on("close", (code) => {
+        if (code === 0 && !hasError) {
+          // Verify the new version
+          const newVersion = this.getCurrentVersion();
+          if (newVersion) {
+            spinner.succeed(
+              `Compact compiler updated successfully to version ${chalk.green(
+                newVersion
+              )}`
+            );
+            resolve(true);
+          } else {
+            spinner.fail("Update completed but could not verify version");
+            resolve(false);
+          }
+        } else {
+          if (!hasError) {
+            spinner.fail(
+              `Failed to update Compact compiler (exit code: ${code})`
+            );
+          }
+          resolve(false);
+        }
+      });
+
+      updateProcess.on("error", (error) => {
+        spinner.fail(`Failed to update Compact compiler: ${error.message}`);
+        resolve(false);
+      });
+    });
+  }
+
+  /**
+   * Handle Compact version mismatch with automatic update option
+   */
+  static async handleVersionMismatch(
+    currentVersion: string,
+    requiredVersion: string
+  ): Promise<boolean> {
+    const shouldUpdate = await this.promptUpdate(
+      currentVersion,
+      requiredVersion
+    );
+
+    if (!shouldUpdate) {
+      console.log(
+        chalk.yellow(
+          `\n⚠️  Skipping update. You can update manually later with:`
+        )
+      );
+      console.log(
+        chalk.gray(
+          `   curl --proto '=https' --tlsv1.2 -LsSf https://github.com/midnightntwrk/compact/releases/latest/download/compact-installer.sh | sh\n`
+        )
+      );
+      return false;
+    }
+
+    const updateSuccess = await this.updateCompact();
+
+    if (!updateSuccess) {
+      console.log(
+        chalk.red(
+          `\n❌ Update failed. Please try updating manually or check your internet connection.\n`
+        )
+      );
+      return false;
+    }
+
+    // Verify the update meets requirements
+    const newVersion = this.getCurrentVersion();
+    if (newVersion && !this.needsUpdate(newVersion, requiredVersion)) {
+      console.log(chalk.green(`\n✓ Compact compiler is now up to date!\n`));
+      return true;
+    } else {
+      console.log(
+        chalk.yellow(
+          `\n⚠️  Update completed, but version may still need manual verification.\n`
+        )
+      );
+      return false;
+    }
+  }
+}

src/utils/requirement-checker.ts

@@ -68,18 +68,34 @@ export class RequirementChecker {
   }
 
   /**
-   * Check Compact compiler availability
+   * Check Compact compiler availability and version
    */
-  static checkCompactCompiler(): RequirementCheck {
+  static checkCompactCompiler(minVersion?: string): RequirementCheck {
     try {
-      const version = execSync("compact compile --version", {
+      const versionOutput = execSync("compact compile --version", {
         encoding: "utf-8",
       }).trim();
+
+      // Extract version number (e.g., "Compactc version: 0.23.0" -> "0.23.0")
+      const versionMatch = versionOutput.match(/(\d+\.\d+\.\d+)/);
+      const currentVersion = versionMatch ? versionMatch[1] : versionOutput;
+
+      // Check version compatibility
+      let isCompatible = true;
+      let versionWarning = "";
+
+      if (minVersion && currentVersion) {
+        isCompatible = this.compareVersions(currentVersion, minVersion) >= 0;
+        if (!isCompatible) {
+          versionWarning = ` (requires ${minVersion}+, found ${currentVersion})`;
+        }
+      }
+
       return {
-        name: "Compact Compiler",
+        name: `Compact Compiler${versionWarning}`,
         required: true,
-        found: true,
-        version: version,
+        found: isCompatible,
+        version: currentVersion,
         installCommand:
           "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/midnightntwrk/compact/releases/latest/download/compact-installer.sh | sh",
       };
@@ -94,6 +110,25 @@ export class RequirementChecker {
     }
   }
 
+  /**
+   * Compare semantic versions (e.g., "0.23.0" vs "0.15.0")
+   * Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+   */
+  private static compareVersions(v1: string, v2: string): number {
+    const parts1 = v1.split(".").map(Number);
+    const parts2 = v2.split(".").map(Number);
+
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+      const part1 = parts1[i] || 0;
+      const part2 = parts2[i] || 0;
+
+      if (part1 > part2) return 1;
+      if (part1 < part2) return -1;
+    }
+
+    return 0;
+  }
+
   /**
    * Display requirement check results
    */