kaven-cli 0.1.0-alpha.1 → 0.3.5

package/dist/commands/auth/login.js

@@ -6,39 +6,117 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.authLogin = authLogin;
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
+const open_1 = __importDefault(require("open"));
 const AuthService_1 = require("../../core/AuthService");
+const MarketplaceClient_1 = require("../../infrastructure/MarketplaceClient");
 const TelemetryBuffer_1 = require("../../infrastructure/TelemetryBuffer");
+/**
+ * Sleep helper for polling delays
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Poll for access token with exponential backoff
+ */
+async function pollForToken(client, deviceCode, expiresIn, initialInterval, spinner) {
+    const deadline = Date.now() + expiresIn * 1000;
+    const backoffIntervals = [5, 10, 15, 20]; // seconds - exponential backoff
+    let backoffIndex = 0;
+    let interval = initialInterval;
+    while (Date.now() < deadline) {
+        // Update countdown spinner
+        const remaining = Math.ceil((deadline - Date.now()) / 1000);
+        const mm = Math.floor(remaining / 60);
+        const ss = String(remaining % 60).padStart(2, '0');
+        spinner.text = `Waiting for authorization... (expires in ${mm}:${ss})`;
+        // Wait for next poll
+        await sleep(interval * 1000);
+        try {
+            const result = await client.pollDeviceToken(deviceCode);
+            // Success - return tokens
+            if (result.status === 'success' && result.tokens) {
+                return result.tokens;
+            }
+            // Handle different status codes
+            switch (result.status) {
+                case 'slow_down':
+                    // Increase interval by 5s as requested by server
+                    interval += 5;
+                    break;
+                case 'access_denied':
+                    throw new Error('Authorization denied by user. Try again with \'kaven auth login\'.');
+                case 'expired_token':
+                    throw new Error('Device code expired. Run \'kaven auth login\' again.');
+                case 'authorization_pending':
+                    // Continue polling - apply exponential backoff
+                    if (backoffIndex < backoffIntervals.length - 1) {
+                        backoffIndex++;
+                        interval = backoffIntervals[backoffIndex];
+                    }
+                    break;
+            }
+        }
+        catch (error) {
+            // Re-throw our custom errors
+            if (error.message.includes('denied') ||
+                error.message.includes('expired')) {
+                throw error;
+            }
+            // Network errors
+            const nodeError = error;
+            if (nodeError.code === 'ECONNREFUSED' || nodeError.code === 'ENOTFOUND') {
+                throw new Error('Network error. Check your connection and try again.');
+            }
+            // Unknown error
+            throw error;
+        }
+    }
+    // Timeout - device code expired
+    throw new Error('Device code expired. Run \'kaven auth login\' again.');
+}
+/**
+ * Main login command - OAuth 2.0 Device Authorization Grant (RFC 8628)
+ */
 async function authLogin() {
     const telemetry = TelemetryBuffer_1.TelemetryBuffer.getInstance();
     const startTime = Date.now();
     telemetry.capture("cli.auth.login.start");
+    const client = new MarketplaceClient_1.MarketplaceClient();
     const authService = new AuthService_1.AuthService();
-    console.log(chalk_1.default.blue("🔐 Iniciando fluxo de autenticação...\n"));
-    const spinner = (0, ora_1.default)("Gerando código de dispositivo...").start();
+    console.log(chalk_1.default.blue("🔐 Starting authentication flow...\n"));
+    const spinner = (0, ora_1.default)("Requesting device code from marketplace...").start();
     try {
-        // Simulando atraso da rede
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        const deviceCode = "KAVEN-777-BINGO";
-        const verificationUrl = "https://kaven.sh/device";
+        // Step 1: Request device code
+        const { device_code, user_code, verification_uri, expires_in, interval } = await client.requestDeviceCode();
         spinner.stop();
-        console.log(chalk_1.default.yellow("Para continuar o login, acesse a URL abaixo e insira o código:"));
-        console.log(chalk_1.default.bold(`\n   URL:    ${verificationUrl}`));
-        console.log(chalk_1.default.bold(`   Código: ${deviceCode}\n`));
-        const pollSpinner = (0, ora_1.default)("Aguardando autorização no navegador...").start();
-        // Simular polling bem-sucedido após 3 segundos
-        await new Promise((resolve) => setTimeout(resolve, 3000));
-        const mockToken = "jwt-mock-token-for-kaven-explorador";
-        await authService.storeToken(mockToken);
-        pollSpinner.succeed(chalk_1.default.green("Autenticação realizada com sucesso!"));
-        console.log(chalk_1.default.gray("\nSeu token foi salvo com segurança em ~/.kaven/auth.json"));
-        telemetry.capture("cli.auth.login.success", {}, Date.now() - startTime);
+        // Step 2: Display code and open browser
+        console.log(chalk_1.default.yellow("To complete login, follow these steps:\n"));
+        console.log(chalk_1.default.bold(`  Your verification code: ${chalk_1.default.cyan(user_code)}\n`));
+        try {
+            await (0, open_1.default)(verification_uri);
+            console.log(chalk_1.default.dim("  ✓ Browser opened automatically"));
+        }
+        catch {
+            console.log(chalk_1.default.yellow(`  Open this URL in your browser:`));
+            console.log(chalk_1.default.underline(`  ${verification_uri}\n`));
+        }
+        // Step 3: Poll for token with exponential backoff
+        const pollSpinner = (0, ora_1.default)('Waiting for authorization...').start();
+        const tokens = await pollForToken(client, device_code, expires_in, interval, pollSpinner);
+        // Step 4: Store tokens securely
+        await authService.saveTokens(tokens);
+        pollSpinner.succeed(chalk_1.default.green(`Logged in as ${chalk_1.default.bold(tokens.user.email)}`));
+        console.log(chalk_1.default.dim(`  Tier: ${tokens.user.tier}`));
+        console.log(chalk_1.default.gray("\n  Your credentials were saved securely in ~/.kaven/auth.json\n"));
+        telemetry.capture("cli.auth.login.success", { tier: tokens.user.tier }, Date.now() - startTime);
         await telemetry.flush();
     }
     catch (error) {
         telemetry.capture("cli.auth.login.error", { error: error.message }, Date.now() - startTime);
         await telemetry.flush();
-        spinner.fail(chalk_1.default.red("Erro ao realizar login."));
-        console.error(error);
+        spinner.fail(chalk_1.default.red("Authentication failed"));
+        console.error(chalk_1.default.red(`\n  Error: ${error.message}\n`));
         process.exit(1);
     }
 }

package/dist/commands/auth/logout.js

@@ -5,21 +5,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.authLogout = authLogout;
 const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
 const AuthService_1 = require("../../core/AuthService");
 async function authLogout() {
     const authService = new AuthService_1.AuthService();
-    const spinner = (0, ora_1.default)("Encerrando sessão...").start();
     try {
         if (!(await authService.isAuthenticated())) {
-            spinner.info(chalk_1.default.yellow("Você não está autenticado."));
+            console.log(chalk_1.default.yellow("You are not authenticated."));
             return;
         }
-        await authService.clearToken();
-        spinner.succeed(chalk_1.default.green("Sessão encerrada com sucesso!"));
+        await authService.logout();
+        console.log(chalk_1.default.green("Logged out successfully."));
     }
     catch {
-        spinner.fail(chalk_1.default.red("Erro ao realizar logout."));
+        console.error(chalk_1.default.red("Error during logout."));
         process.exit(1);
     }
 }

package/dist/commands/auth/whoami.js

@@ -12,24 +12,25 @@ async function authWhoami() {
     telemetry.capture("cli.auth.whoami.start");
     const authService = new AuthService_1.AuthService();
     try {
-        const userInfo = await authService.getUserInfo();
-        if (!userInfo) {
-            console.log(chalk_1.default.yellow("Você não está autenticado."));
-            console.log(chalk_1.default.gray("Use 'kaven auth login' para entrar."));
+        const info = await authService.getWhoamiInfo();
+        if (!info) {
+            console.log(chalk_1.default.yellow("You are not authenticated."));
+            console.log(chalk_1.default.gray("Use 'kaven auth login' to sign in."));
             telemetry.capture("cli.auth.whoami.not_authenticated");
             await telemetry.flush();
             return;
         }
         telemetry.capture("cli.auth.whoami.authenticated");
-        console.log(chalk_1.default.blue("👤 Usuário logado:"));
-        console.log(`${chalk_1.default.bold("ID:")}    ${userInfo.id}`);
-        console.log(`${chalk_1.default.bold("E-mail:")} ${userInfo.email}`);
-        if (userInfo.name) {
-            console.log(`${chalk_1.default.bold("Nome:")}   ${userInfo.name}`);
-        }
+        console.log();
+        console.log(`  ${chalk_1.default.bold("Email:")}    ${info.email}`);
+        console.log(`  ${chalk_1.default.bold("GitHub:")}   ${info.githubId}`);
+        console.log(`  ${chalk_1.default.bold("Tier:")}     ${info.tier}`);
+        console.log(`  ${chalk_1.default.bold("Session:")}  ${info.sessionExpiry}`);
+        console.log();
     }
     catch {
-        console.error(chalk_1.default.red("Erro ao verificar status de autenticação."));
+        console.error(chalk_1.default.red("Error checking authentication status."));
         process.exit(1);
     }
+    await telemetry.flush();
 }

package/dist/commands/cache/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheStatus = cacheStatus;
+exports.cacheClear = cacheClear;
+const chalk_1 = __importDefault(require("chalk"));
+const CacheManager_1 = require("../../core/CacheManager");
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+async function cacheStatus() {
+    const manager = (0, CacheManager_1.getCacheManager)();
+    const stats = await manager.stats();
+    console.log(chalk_1.default.bold("\nKaven CLI Cache Status\n"));
+    console.log(`  Cache directory:  ${chalk_1.default.cyan(manager.cacheDir)}`);
+    console.log(`  Total size:       ${chalk_1.default.cyan(formatBytes(stats.totalSize))}`);
+    console.log(`  Cached entries:   ${chalk_1.default.cyan(stats.entries.toString())}`);
+    if (stats.oldest) {
+        console.log(`  Oldest entry:     ${chalk_1.default.gray(stats.oldest.toLocaleString())}`);
+    }
+    if (stats.newest) {
+        console.log(`  Newest entry:     ${chalk_1.default.gray(stats.newest.toLocaleString())}`);
+    }
+    console.log();
+    console.log(chalk_1.default.gray("Run 'kaven cache clear' to remove all cached data."));
+}
+async function cacheClear() {
+    const manager = (0, CacheManager_1.getCacheManager)();
+    const stats = await manager.stats();
+    if (stats.entries === 0) {
+        console.log(chalk_1.default.gray("Cache is already empty."));
+        return;
+    }
+    await manager.clear();
+    console.log(chalk_1.default.green(`Cache cleared: ${stats.entries} entries (${formatBytes(stats.totalSize)}) removed.`));
+}

package/dist/commands/config/index.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSet = configSet;
+exports.configGet = configGet;
+exports.configView = configView;
+exports.configReset = configReset;
+const chalk_1 = __importDefault(require("chalk"));
+const ConfigManager_1 = require("../../core/ConfigManager");
+/**
+ * C2.4: Config set — Persist value to ~/.kaven/config.json
+ */
+async function configSet(key, value) {
+    if (!key || !value) {
+        console.error(chalk_1.default.red("Error: Both key and value are required"));
+        console.error(chalk_1.default.gray("Usage: kaven config set KEY VALUE"));
+        process.exit(1);
+    }
+    await ConfigManager_1.configManager.initialize();
+    try {
+        await ConfigManager_1.configManager.set(key, value);
+        console.log(chalk_1.default.green(`✅ Set ${chalk_1.default.bold(key)} = ${chalk_1.default.bold(value)}`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+}
+/**
+ * C2.4: Config get — Read with defaults
+ */
+async function configGet(key, options) {
+    if (!key) {
+        console.error(chalk_1.default.red("Error: Key is required"));
+        console.error(chalk_1.default.gray("Usage: kaven config get KEY"));
+        process.exit(1);
+    }
+    await ConfigManager_1.configManager.initialize();
+    try {
+        const value = ConfigManager_1.configManager.get(key);
+        if (options.json) {
+            console.log(JSON.stringify({ [key]: value }, null, 2));
+        }
+        else {
+            console.log(value);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+}
+/**
+ * C2.4: Config view — Show all configuration
+ */
+async function configView(options) {
+    await ConfigManager_1.configManager.initialize();
+    const config = ConfigManager_1.configManager.getAll();
+    if (options.json) {
+        console.log(JSON.stringify(config, null, 2));
+    }
+    else {
+        console.log(chalk_1.default.bold("Kaven Configuration:"));
+        console.log(chalk_1.default.gray(`Location: ${ConfigManager_1.configManager.getConfigDir()}/config.json`));
+        console.log();
+        const entries = Object.entries(config);
+        const maxKeyLen = Math.max(...entries.map(([k]) => k.length));
+        for (const [key, value] of entries) {
+            const padding = " ".repeat(maxKeyLen - key.length);
+            const displayValue = typeof value === "object"
+                ? JSON.stringify(value, null, 2).replace(/\n/g, "\n" + " ".repeat(maxKeyLen + 3))
+                : value;
+            console.log(`  ${key}${padding}  ${chalk_1.default.cyan(displayValue)}`);
+        }
+    }
+}
+/**
+ * C2.4: Config reset — Reset to defaults
+ */
+async function configReset() {
+    const { confirm } = await Promise.resolve().then(() => __importStar(require("@inquirer/prompts")));
+    const confirmed = await confirm({
+        message: "Are you sure you want to reset config to defaults?",
+        default: false,
+    });
+    if (!confirmed) {
+        console.log(chalk_1.default.yellow("Cancelled."));
+        return;
+    }
+    await ConfigManager_1.configManager.initialize();
+    await ConfigManager_1.configManager.reset();
+    console.log(chalk_1.default.green("✅ Config reset to defaults"));
+}

package/dist/commands/init/index.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initProject = initProject;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const ProjectInitializer_1 = require("../../core/ProjectInitializer");
+const ConfigManager_1 = require("../../core/ConfigManager");
+async function promptAnswers(projectName) {
+    // Dynamic import to keep startup fast and avoid issues if not installed
+    const { input, select } = await Promise.resolve().then(() => __importStar(require("@inquirer/prompts")));
+    // Load defaults from config if available
+    await ConfigManager_1.configManager.initialize();
+    const existingDefaults = ConfigManager_1.configManager.getAll().projectDefaults || {};
+    const dbUrl = await input({
+        message: "Database URL (PostgreSQL):",
+        default: existingDefaults.dbUrl ||
+            `postgresql://user:password@localhost:5432/${projectName}`,
+    });
+    const emailProvider = await select({
+        message: "Email provider:",
+        choices: [
+            { name: "Postmark", value: "postmark" },
+            { name: "Resend", value: "resend" },
+            { name: "AWS SES", value: "ses" },
+            { name: "SMTP", value: "smtp" },
+        ],
+        default: existingDefaults.emailProvider || "postmark",
+    });
+    const locale = await input({
+        message: "Default locale:",
+        default: existingDefaults.locale || "en-US",
+    });
+    const currency = await input({
+        message: "Default currency:",
+        default: existingDefaults.currency || "USD",
+    });
+    return { dbUrl, emailProvider, locale, currency };
+}
+async function initProject(projectName, options) {
+    const initializer = new ProjectInitializer_1.ProjectInitializer();
+    // Determine project name interactively if not provided
+    let resolvedName = projectName ?? "";
+    if (!resolvedName) {
+        if (options.defaults) {
+            resolvedName = "my-kaven-app";
+        }
+        else {
+            const { input } = await Promise.resolve().then(() => __importStar(require("@inquirer/prompts")));
+            resolvedName = await input({
+                message: "Project name:",
+                default: "my-kaven-app",
+            });
+        }
+    }
+    // Validate name
+    const validation = initializer.validateName(resolvedName);
+    if (!validation.valid) {
+        console.error(chalk_1.default.red(`Error: ${validation.reason}`));
+        console.error(chalk_1.default.gray("Try: kaven init my-project-name (use lowercase letters and hyphens)"));
+        process.exit(1);
+    }
+    const name = resolvedName;
+    const targetDir = path_1.default.resolve(process.cwd(), name);
+    // Check if directory already exists
+    if ((await fs_extra_1.default.pathExists(targetDir)) && !options.force) {
+        console.error(chalk_1.default.red(`Error: Directory "${name}" already exists. Use --force to overwrite.`));
+        process.exit(1);
+    }
+    // Get prompt answers or use defaults
+    let answers;
+    if (options.defaults) {
+        // Try to load from config, then fallback to options
+        await ConfigManager_1.configManager.initialize();
+        const configDefaults = ConfigManager_1.configManager.getAll().projectDefaults || {};
+        answers = {
+            dbUrl: options.dbUrl ||
+                configDefaults.dbUrl ||
+                `postgresql://user:password@localhost:5432/${name}`,
+            emailProvider: options.emailProvider || configDefaults.emailProvider || "postmark",
+            locale: options.locale || configDefaults.locale || "en-US",
+            currency: options.currency || configDefaults.currency || "USD",
+        };
+    }
+    else {
+        answers = await promptAnswers(name);
+    }
+    console.log();
+    // Clone template
+    const cloneSpinner = (0, ora_1.default)("Cloning kaven-template...").start();
+    try {
+        await initializer.cloneTemplate(targetDir);
+        cloneSpinner.succeed("Template cloned successfully");
+    }
+    catch (error) {
+        cloneSpinner.fail("Failed to clone template");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        console.error(chalk_1.default.gray("Try: ensure git is installed and you have internet access"));
+        process.exit(1);
+    }
+    // Remove .git directory
+    const gitRemoveSpinner = (0, ora_1.default)("Removing .git directory...").start();
+    await initializer.removeGitDir(targetDir);
+    gitRemoveSpinner.succeed(".git directory removed");
+    // Replace placeholders
+    const placeholderSpinner = (0, ora_1.default)("Configuring project files...").start();
+    await initializer.replacePlaceholders(targetDir, {
+        ...answers,
+        projectName: name,
+    });
+    placeholderSpinner.succeed("Project files configured");
+    // Run pnpm install
+    if (!options.skipInstall) {
+        const installSpinner = (0, ora_1.default)("Installing dependencies (pnpm install)...").start();
+        try {
+            await initializer.runInstall(targetDir);
+            installSpinner.succeed("Dependencies installed");
+        }
+        catch (error) {
+            installSpinner.warn("Dependency installation failed — run pnpm install manually");
+            console.error(chalk_1.default.gray(error instanceof Error ? error.message : String(error)));
+        }
+    }
+    // Init git
+    if (!options.skipGit) {
+        const gitSpinner = (0, ora_1.default)("Initializing git repository...").start();
+        try {
+            await initializer.initGit(targetDir);
+            gitSpinner.succeed("Git repository initialized");
+        }
+        catch (error) {
+            gitSpinner.warn("Git init failed — initialize manually");
+            console.error(chalk_1.default.gray(error instanceof Error ? error.message : String(error)));
+        }
+    }
+    // Health check
+    const healthCheckSpinner = (0, ora_1.default)("Running health check...").start();
+    const health = await initializer.healthCheck(targetDir);
+    if (health.healthy) {
+        healthCheckSpinner.succeed("Health check passed");
+    }
+    else {
+        healthCheckSpinner.warn("Health check found issues:");
+        for (const issue of health.issues) {
+            console.log(chalk_1.default.yellow(`  ⚠ ${issue}`));
+        }
+    }
+    // Success message
+    console.log();
+    console.log(chalk_1.default.green("✅ Project created successfully!"));
+    console.log();
+    console.log(chalk_1.default.bold("Next steps:"));
+    console.log(chalk_1.default.cyan(`  cd ${name}`));
+    console.log(chalk_1.default.cyan("  cp .env.example .env"));
+    console.log(chalk_1.default.cyan("  npx prisma migrate dev"));
+    console.log(chalk_1.default.cyan("  pnpm dev"));
+    console.log();
+    console.log(chalk_1.default.gray("For more help, visit: https://docs.kaven.sh/getting-started"));
+    // Save project defaults to config for future use
+    await ConfigManager_1.configManager.initialize();
+    try {
+        await ConfigManager_1.configManager.set("projectDefaults", {
+            dbUrl: answers.dbUrl,
+            emailProvider: answers.emailProvider,
+            locale: answers.locale,
+            currency: answers.currency,
+        });
+    }
+    catch {
+        // Non-critical, continue if config save fails
+    }
+}