kaven-cli 0.1.0-alpha.1 → 0.3.0

package/dist/commands/module/doctor.js

@@ -5,11 +5,103 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.moduleDoctor = moduleDoctor;
 const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const ModuleDoctor_1 = require("../../core/ModuleDoctor");
 const MarkerService_1 = require("../../core/MarkerService");
 const ManifestParser_1 = require("../../core/ManifestParser");
+function severityPrefix(severity) {
+    switch (severity) {
+        case "error":
+            return chalk_1.default.red("[ERROR]");
+        case "warning":
+            return chalk_1.default.yellow("[WARN] ");
+        case "info":
+            return chalk_1.default.cyan("[INFO] ");
+        default:
+            return chalk_1.default.green("[OK]   ");
+    }
+}
+/** Attempt auto-fixes for fixable issues. */
+async function applyFixes(results, projectRoot) {
+    const fixable = results.filter((r) => r.fixable);
+    if (fixable.length === 0) {
+        console.log(chalk_1.default.gray("   No automatically fixable issues found."));
+        return;
+    }
+    for (const result of fixable) {
+        const msg = result.message.toLowerCase();
+        // Missing npm deps: run pnpm install
+        if (msg.includes("missing npm dependency") || msg.includes("pnpm install")) {
+            console.log(chalk_1.default.blue(`  Fixing: ${result.message}`));
+            try {
+                (0, child_process_1.execSync)("pnpm install", { cwd: projectRoot, stdio: "inherit" });
+                console.log(chalk_1.default.green("  ✓ pnpm install completed"));
+            }
+            catch {
+                console.log(chalk_1.default.red("  ✗ pnpm install failed"));
+            }
+            continue;
+        }
+        // Stale Prisma: run prisma generate
+        if (msg.includes("prisma")) {
+            console.log(chalk_1.default.blue(`  Fixing: ${result.message}`));
+            try {
+                (0, child_process_1.execSync)("npx prisma generate", { cwd: projectRoot, stdio: "inherit" });
+                console.log(chalk_1.default.green("  ✓ npx prisma generate completed"));
+            }
+            catch {
+                console.log(chalk_1.default.red("  ✗ npx prisma generate failed"));
+            }
+            continue;
+        }
+        // Missing env vars: append placeholder
+        if (msg.includes("missing env vars") && result.file === ".env") {
+            const envPath = path_1.default.join(projectRoot, ".env");
+            const envExamplePath = path_1.default.join(projectRoot, ".env.example");
+            console.log(chalk_1.default.blue(`  Fixing: ${result.message}`));
+            try {
+                const exampleContent = await fs_extra_1.default.readFile(envExamplePath, "utf-8");
+                const envContent = (await fs_extra_1.default.pathExists(envPath))
+                    ? await fs_extra_1.default.readFile(envPath, "utf-8")
+                    : "";
+                const parseKeys = (content) => {
+                    const keys = new Set();
+                    for (const line of content.split("\n")) {
+                        const trimmed = line.trim();
+                        if (trimmed.startsWith("#") || !trimmed.includes("="))
+                            continue;
+                        const key = trimmed.split("=")[0].trim();
+                        if (key)
+                            keys.add(key);
+                    }
+                    return keys;
+                };
+                const exampleKeys = parseKeys(exampleContent);
+                const envKeys = parseKeys(envContent);
+                let appendContent = "\n# Added by kaven doctor --fix\n";
+                for (const key of exampleKeys) {
+                    if (!envKeys.has(key)) {
+                        appendContent += `${key}=PLACEHOLDER\n`;
+                    }
+                }
+                await fs_extra_1.default.appendFile(envPath, appendContent);
+                console.log(chalk_1.default.green("  ✓ Placeholder env vars appended to .env"));
+            }
+            catch {
+                console.log(chalk_1.default.red("  ✗ Could not append env vars"));
+            }
+            continue;
+        }
+        // Generic fallback
+        console.log(chalk_1.default.yellow(`  Manual action required: ${result.message}`));
+    }
+}
 async function moduleDoctor(options) {
-    console.log(chalk_1.default.blue("🔍 Running module doctor...\n"));
+    if (!options.json) {
+        console.log(chalk_1.default.blue("Running module doctor...\n"));
+    }
     const markerService = new MarkerService_1.MarkerService();
     const manifestParser = new ManifestParser_1.ManifestParser();
     const doctor = new ModuleDoctor_1.ModuleDoctor(process.cwd(), markerService, manifestParser);
@@ -18,53 +110,66 @@ async function moduleDoctor(options) {
         results = await doctor.checkAll();
     }
     catch (error) {
-        console.error(chalk_1.default.red(`❌ Heavy failure during doctor audit: ${error instanceof Error ? error.message : String(error)}`));
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: error instanceof Error ? error.message : String(error), results: [] }));
+        }
+        else {
+            console.error(chalk_1.default.red(`[ERROR] Heavy failure during doctor audit: ${error instanceof Error ? error.message : String(error)}`));
+        }
         process.exit(1);
+        return;
     }
-    if (results.length === 0) {
-        console.log(chalk_1.default.green("✅ All checks passed! Your modules are healthy.\n"));
+    // JSON output mode
+    if (options.json) {
+        const errors = results.filter((r) => r.severity === "error");
+        const warnings = results.filter((r) => r.severity === "warning");
+        console.log(JSON.stringify({
+            success: errors.length === 0,
+            errors: errors.length,
+            warnings: warnings.length,
+            results,
+        }, null, 2));
+        process.exit(errors.length > 0 ? 1 : warnings.length > 0 ? 2 : 0);
         return;
     }
-    // Grupar por severidade
+    // Human-readable output
+    for (const result of results) {
+        const prefix = severityPrefix(result.severity);
+        console.log(`${prefix} ${result.message}`);
+        if (result.file) {
+            console.log(chalk_1.default.gray(`         file: ${result.file}`));
+        }
+        if (result.fixable && !options.fix) {
+            console.log(chalk_1.default.gray(`         (fixable: run with --fix)`));
+        }
+    }
     const errors = results.filter((r) => r.severity === "error");
     const warnings = results.filter((r) => r.severity === "warning");
-    if (errors.length > 0) {
-        console.log(chalk_1.default.red(`❌ Found ${errors.length} error(s):\n`));
-        for (const err of errors) {
-            console.log(chalk_1.default.red(`   ${err.message}`));
-            if (err.file)
-                console.log(chalk_1.default.gray(`      file: ${err.file}`));
-            if (err.fixable)
-                console.log(chalk_1.default.yellow(`      (💡 tip: run with --fix to attempt repair)`));
-            console.log();
-        }
+    console.log();
+    if (errors.length === 0 && warnings.length === 0) {
+        console.log(chalk_1.default.green("[OK]    All checks passed! Your project is healthy."));
     }
-    if (warnings.length > 0) {
-        console.log(chalk_1.default.yellow(`⚠️  Found ${warnings.length} warning(s):\n`));
-        for (const warn of warnings) {
-            console.log(chalk_1.default.yellow(`   ${warn.message}`));
-            if (warn.file)
-                console.log(chalk_1.default.gray(`      file: ${warn.file}`));
-            console.log();
+    else {
+        if (errors.length > 0) {
+            console.log(chalk_1.default.red(`[ERROR] Found ${errors.length} error(s)`));
         }
-    }
-    if (options.fix) {
-        console.log(chalk_1.default.blue("🔧 Attempting to fix issues...\n"));
-        const fixable = results.filter((r) => r.fixable);
-        if (fixable.length === 0) {
-            console.log(chalk_1.default.gray("   No issues are automatically fixable yet."));
+        if (warnings.length > 0) {
+            console.log(chalk_1.default.yellow(`[WARN]  Found ${warnings.length} warning(s)`));
         }
-        for (const result of fixable) {
-            // Nota: No roadmap Week 2, a reparação real pode ser um placeholder
-            // ou apenas o log de tentativa, dependendo da complexidade.
-            // Por enquanto, apenas reportamos que a reparação automática
-            // será implementada conforme o ModuleInstaller for refinado.
-            console.log(chalk_1.default.yellow(`   🚧 Manual repair required for: ${result.message}. Autofix coming in future release.`));
+        if (!options.fix) {
+            console.log(chalk_1.default.gray("\nTip: Run with --fix to attempt automatic repairs"));
+            console.log(chalk_1.default.gray("Try: kaven module doctor --fix"));
         }
-        console.log(chalk_1.default.green("\n✅ Audit complete. Fixes were logged for manual action.\n"));
     }
-    else {
-        console.log(chalk_1.default.blue("💡 Tip: Run with --fix to see potential repairs\n"));
+    if (options.fix) {
+        console.log();
+        console.log(chalk_1.default.blue("Applying auto-fixes...\n"));
+        await applyFixes(results, process.cwd());
+        console.log(chalk_1.default.green("\nAuto-fix completed."));
     }
-    process.exit(errors.length > 0 ? 1 : 0);
+    // Exit codes: 0=all pass, 1=errors, 2=warnings only
+    if (errors.length > 0)
+        process.exit(1);
+    if (warnings.length > 0)
+        process.exit(2);
 }

package/dist/commands/module/publish.js

@@ -0,0 +1,291 @@
+"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.moduleJsonSchema = void 0;
+exports.modulePublish = modulePublish;
+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 crypto_1 = __importDefault(require("crypto"));
+const os_1 = __importDefault(require("os"));
+const zod_1 = require("zod");
+const AuthService_1 = require("../../core/AuthService");
+const MarketplaceClient_1 = require("../../infrastructure/MarketplaceClient");
+// Zod schema for module.json
+exports.moduleJsonSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    slug: zod_1.z.string().min(1).regex(/^[a-z0-9-]+$/),
+    version: zod_1.z.string().regex(/^\d+\.\d+\.\d+$/),
+    description: zod_1.z.string().min(1),
+    author: zod_1.z.string().optional(),
+    license: zod_1.z.string().optional(),
+    tier: zod_1.z.enum(["free", "starter", "complete", "pro"]),
+});
+const SIGNING_KEY_PATH = path_1.default.join(os_1.default.homedir(), ".kaven", "signing-key.json");
+/** Load or generate Ed25519 signing key pair. */
+async function getSigningKey() {
+    if (await fs_extra_1.default.pathExists(SIGNING_KEY_PATH)) {
+        try {
+            const stored = await fs_extra_1.default.readJson(SIGNING_KEY_PATH);
+            const privateKey = crypto_1.default.createPrivateKey({
+                key: Buffer.from(stored.privateKey, "base64"),
+                type: "pkcs8",
+                format: "der",
+            });
+            const publicKey = crypto_1.default.createPublicKey(privateKey);
+            return { privateKey, publicKey };
+        }
+        catch {
+            // Fall through to generate new key
+        }
+    }
+    const { privateKey, publicKey } = crypto_1.default.generateKeyPairSync("ed25519");
+    const privateKeyDer = privateKey.export({ type: "pkcs8", format: "der" });
+    const publicKeyDer = publicKey.export({ type: "spki", format: "der" });
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(SIGNING_KEY_PATH));
+    await fs_extra_1.default.writeJson(SIGNING_KEY_PATH, {
+        privateKey: privateKeyDer.toString("base64"),
+        publicKey: publicKeyDer.toString("base64"),
+    }, { spaces: 2 });
+    if (process.platform !== "win32") {
+        await fs_extra_1.default.chmod(SIGNING_KEY_PATH, 0o600);
+    }
+    return { privateKey, publicKey };
+}
+/** Generate SHA-256 checksum of a file. */
+async function sha256File(filePath) {
+    const data = await fs_extra_1.default.readFile(filePath);
+    return crypto_1.default.createHash("sha256").update(data).digest("hex");
+}
+/** Create tar.gz archive of current directory, excluding common noise. */
+async function createTarball(sourceDir, outputPath) {
+    const tar = await Promise.resolve().then(() => __importStar(require("tar")));
+    await tar.create({
+        gzip: true,
+        file: outputPath,
+        cwd: sourceDir,
+        filter: (filePath) => {
+            const normalized = filePath.replace(/\\/g, "/");
+            const excluded = [
+                "node_modules",
+                ".git",
+                "dist",
+                ".env",
+            ];
+            for (const exc of excluded) {
+                if (normalized.startsWith(exc + "/") ||
+                    normalized === exc ||
+                    normalized.endsWith(".log")) {
+                    return false;
+                }
+            }
+            return true;
+        },
+    }, ["."]);
+}
+async function modulePublish(options) {
+    const cwd = process.cwd();
+    // 1. Read and validate module.json
+    const moduleJsonPath = path_1.default.join(cwd, "module.json");
+    if (!(await fs_extra_1.default.pathExists(moduleJsonPath))) {
+        console.error(chalk_1.default.red("Error: module.json not found in current directory."));
+        console.error(chalk_1.default.gray("Try: run this command from inside a module directory"));
+        process.exit(1);
+    }
+    let moduleJson;
+    try {
+        const raw = await fs_extra_1.default.readJson(moduleJsonPath);
+        const result = exports.moduleJsonSchema.safeParse(raw);
+        if (!result.success) {
+            console.error(chalk_1.default.red("Error: Invalid module.json:"));
+            for (const issue of result.error.issues) {
+                console.error(chalk_1.default.red(`  - ${issue.path.join(".")}: ${issue.message}`));
+            }
+            process.exit(1);
+        }
+        moduleJson = result.data;
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: Failed to parse module.json: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+    console.log();
+    console.log(chalk_1.default.bold(`Publishing module: ${moduleJson.name} v${moduleJson.version}`));
+    console.log(chalk_1.default.gray(`Slug: ${moduleJson.slug} | Tier: ${moduleJson.tier}`));
+    console.log();
+    // 2. Create tar.gz
+    const tarballPath = path_1.default.join(os_1.default.tmpdir(), `kaven-${moduleJson.slug}-${moduleJson.version}.tar.gz`);
+    const packageSpinner = (0, ora_1.default)("Creating module package...").start();
+    try {
+        await createTarball(cwd, tarballPath);
+        const stats = await fs_extra_1.default.stat(tarballPath);
+        packageSpinner.succeed(`Package created (${(stats.size / 1024).toFixed(1)} KB)`);
+    }
+    catch (error) {
+        packageSpinner.fail("Failed to create package");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+    }
+    // 3. Generate checksum
+    const checksumSpinner = (0, ora_1.default)("Computing SHA-256 checksum...").start();
+    let checksum;
+    try {
+        checksum = await sha256File(tarballPath);
+        checksumSpinner.succeed(`Checksum: ${checksum.substring(0, 16)}...`);
+    }
+    catch {
+        checksumSpinner.fail("Failed to compute checksum");
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    // 4. Sign the checksum
+    const signSpinner = (0, ora_1.default)("Signing package...").start();
+    let signatureBase64;
+    let publicKeyBase64;
+    try {
+        const { privateKey, publicKey } = await getSigningKey();
+        const signature = crypto_1.default.sign(null, Buffer.from(checksum), privateKey);
+        signatureBase64 = signature.toString("base64");
+        const publicKeyDer = publicKey.export({
+            type: "spki", format: "der",
+        });
+        publicKeyBase64 = publicKeyDer.toString("base64");
+        signSpinner.succeed(`Package signed (${signatureBase64.substring(0, 16)}...)`);
+    }
+    catch {
+        signSpinner.fail("Failed to sign package");
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    if (options.dryRun) {
+        console.log();
+        console.log(chalk_1.default.yellow("Dry-run mode: skipping upload and release creation."));
+        console.log(chalk_1.default.green("✅ Package validated successfully."));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        return;
+    }
+    // 5. Get presigned upload URL
+    const authService = new AuthService_1.AuthService();
+    try {
+        await authService.getValidToken();
+    }
+    catch {
+        console.error(chalk_1.default.red("Error: Not authenticated. Run 'kaven auth login' first."));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    const client = new MarketplaceClient_1.MarketplaceClient(authService);
+    const stats = await fs_extra_1.default.stat(tarballPath);
+    const urlSpinner = (0, ora_1.default)("Getting upload URL...").start();
+    let uploadUrl;
+    let s3Key;
+    try {
+        const uploadUrlResult = await client.getUploadUrl(moduleJson.slug, moduleJson.version, stats.size);
+        uploadUrl = uploadUrlResult.uploadUrl;
+        s3Key = uploadUrlResult.s3Key;
+        urlSpinner.succeed("Upload URL received");
+    }
+    catch (error) {
+        urlSpinner.fail("Failed to get upload URL");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    // 6. Upload tar.gz to presigned URL
+    const uploadSpinner = (0, ora_1.default)(`Uploading package (${(stats.size / 1024).toFixed(1)} KB)...`).start();
+    try {
+        const fileBuffer = await fs_extra_1.default.readFile(tarballPath);
+        const response = await fetch(uploadUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/gzip",
+                "Content-Length": String(stats.size),
+            },
+            body: fileBuffer,
+        });
+        if (!response.ok) {
+            throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
+        }
+        uploadSpinner.succeed("Package uploaded successfully");
+    }
+    catch (error) {
+        uploadSpinner.fail("Upload failed");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    // 7. Create release record
+    const releaseSpinner = (0, ora_1.default)("Creating release record...").start();
+    try {
+        const release = await client.createRelease({
+            moduleSlug: moduleJson.slug,
+            version: moduleJson.version,
+            s3Key,
+            checksum,
+            signature: signatureBase64,
+            publicKey: publicKeyBase64,
+            changelog: options.changelog,
+        });
+        releaseSpinner.succeed(`Release created: ${moduleJson.slug}@${release.version} (ID: ${release.id})`);
+    }
+    catch (error) {
+        releaseSpinner.fail("Failed to create release");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    // Cleanup temp file
+    await fs_extra_1.default.remove(tarballPath).catch(() => { });
+    console.log();
+    console.log(chalk_1.default.green(`✅ Published ${moduleJson.name} v${moduleJson.version} to the Kaven Marketplace!`));
+    console.log(chalk_1.default.gray(`View your module at: https://marketplace.kaven.sh/modules/${moduleJson.slug}`));
+    // Show next steps
+    console.log();
+    console.log(chalk_1.default.bold("Next steps:"));
+    console.log(chalk_1.default.gray("  1. Share your module with the community"));
+    console.log(chalk_1.default.gray("  2. Monitor installation metrics"));
+    console.log(chalk_1.default.gray("  3. Update module with 'kaven module publish' when ready"));
+}

package/dist/commands/upgrade/check.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upgradeCheck = upgradeCheck;
+exports.upgradeInstall = upgradeInstall;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const packageJsonPath = path_1.default.join(__dirname, "../../..", "package.json");
+const PACKAGE_JSON = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf8"));
+const CURRENT_VERSION = PACKAGE_JSON.version;
+const CLI_NAME = "kaven-cli";
+/**
+ * C2.3: Check for CLI updates
+ */
+async function upgradeCheck() {
+    const spinner = (0, ora_1.default)("Checking for updates...").start();
+    try {
+        // Fetch latest version from npm registry
+        const response = await fetch(`https://registry.npmjs.org/${CLI_NAME}`);
+        if (!response.ok) {
+            spinner.fail("Could not check for updates");
+            return;
+        }
+        const data = (await response.json());
+        const distTags = data["dist-tags"];
+        const latestVersion = distTags?.latest || CURRENT_VERSION;
+        spinner.stop();
+        console.log();
+        console.log(chalk_1.default.bold("Version Check:"));
+        console.log(`  Current:  ${chalk_1.default.cyan(CURRENT_VERSION)}`);
+        console.log(`  Latest:   ${chalk_1.default.cyan(latestVersion)}`);
+        console.log();
+        if (latestVersion === CURRENT_VERSION) {
+            console.log(chalk_1.default.green("✅ You're on the latest version!"));
+            return;
+        }
+        // Check if update available
+        const current = parseVersion(CURRENT_VERSION);
+        const latest = parseVersion(latestVersion);
+        if (latest.major > current.major ||
+            (latest.major === current.major && latest.minor > current.minor) ||
+            (latest.major === current.major &&
+                latest.minor === current.minor &&
+                latest.patch > current.patch)) {
+            console.log(chalk_1.default.yellow(`⚠ Update available: ${latestVersion}`));
+            console.log();
+            console.log(chalk_1.default.bold("To upgrade, run:"));
+            console.log(chalk_1.default.cyan(`  npm install -g ${CLI_NAME}@latest`));
+            console.log(chalk_1.default.cyan(`  or`));
+            console.log(chalk_1.default.cyan(`  pnpm add -g ${CLI_NAME}@latest`));
+            console.log();
+            console.log(chalk_1.default.gray("Release notes: https://github.com/kaven-co/kaven-cli/releases"));
+        }
+        else {
+            console.log(chalk_1.default.green("✅ You're on the latest version!"));
+        }
+    }
+    catch (error) {
+        spinner.fail(`Check failed: ${error instanceof Error ? error.message : String(error)}`);
+        console.log(chalk_1.default.gray("You can manually check at: https://www.npmjs.com/package/kaven-cli"));
+    }
+}
+/**
+ * C2.3: Install latest CLI version
+ */
+async function upgradeInstall() {
+    console.log();
+    const spinner = (0, ora_1.default)("Fetching latest version...").start();
+    try {
+        // Get latest version
+        const response = await fetch(`https://registry.npmjs.org/${CLI_NAME}`);
+        if (!response.ok) {
+            throw new Error("Failed to fetch package info");
+        }
+        const data = (await response.json());
+        const distTags = data["dist-tags"];
+        const latestVersion = distTags?.latest || CURRENT_VERSION;
+        if (latestVersion === CURRENT_VERSION) {
+            spinner.succeed("Already on latest version");
+            return;
+        }
+        spinner.text = `Installing ${CLI_NAME}@${latestVersion}...`;
+        // Determine package manager
+        const packageManager = process.env.npm_config_user_agent?.includes("pnpm")
+            ? "pnpm"
+            : "npm";
+        // Install with appropriate package manager
+        const exitCode = await runCommand(packageManager, [
+            "install",
+            "-g",
+            `${CLI_NAME}@${latestVersion}`,
+        ]);
+        if (exitCode !== 0) {
+            spinner.fail(`Installation failed with exit code ${exitCode}`);
+            console.error(chalk_1.default.gray(`Try: ${packageManager} install -g ${CLI_NAME}@latest`));
+            process.exit(1);
+            return;
+        }
+        spinner.succeed(`Updated to ${latestVersion}`);
+        // Health check after install
+        const healthSpinner = (0, ora_1.default)("Running health check...").start();
+        const health = await verifyInstallation();
+        if (health.ok) {
+            healthSpinner.succeed("Installation verified");
+            console.log();
+            console.log(chalk_1.default.green("✅ CLI upgraded successfully!"));
+            console.log(chalk_1.default.gray("Try: kaven --version"));
+        }
+        else {
+            healthSpinner.warn("Installation verification failed");
+            console.log(chalk_1.default.yellow(health.errors.join("\n")));
+        }
+    }
+    catch (error) {
+        spinner.fail(`Installation failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+/**
+ * Verify CLI installation is working
+ */
+async function verifyInstallation() {
+    const errors = [];
+    try {
+        // Check if kaven command is available
+        const code = await runCommand("kaven", ["--version"], { stdio: "pipe" });
+        if (code !== 0) {
+            errors.push("kaven command not available in PATH");
+        }
+    }
+    catch {
+        errors.push("Could not execute kaven command");
+    }
+    return { ok: errors.length === 0, errors };
+}
+/**
+ * Run shell command
+ */
+function runCommand(cmd, args, options) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(cmd, args, options || { stdio: "inherit" });
+        proc.on("error", reject);
+        proc.on("close", (code) => resolve(code ?? 0));
+    });
+}
+/**
+ * Parse semver version
+ */
+function parseVersion(version) {
+    const cleaned = version.replace(/^v/, "").split("-")[0];
+    const [major, minor, patch] = cleaned.split(".").map(Number);
+    return {
+        major: major || 0,
+        minor: minor || 0,
+        patch: patch || 0,
+    };
+}