kaven-cli 0.1.0-alpha.1 → 0.3.5

package/dist/commands/marketplace/install.js

@@ -1,4 +1,37 @@
 "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 };
 };
@@ -9,51 +42,222 @@ const ora_1 = __importDefault(require("ora"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
+const tar = __importStar(require("tar"));
 const MarketplaceClient_1 = require("../../infrastructure/MarketplaceClient");
 const AuthService_1 = require("../../core/AuthService");
-const add_1 = require("../module/add");
+const ModuleInstaller_1 = require("../../core/ModuleInstaller");
+const MarkerService_1 = require("../../core/MarkerService");
 const TelemetryBuffer_1 = require("../../infrastructure/TelemetryBuffer");
-async function marketplaceInstall(moduleId) {
+const errors_1 = require("../../infrastructure/errors");
+const SignatureVerifier_1 = require("../../core/SignatureVerifier");
+/** Create a unique temp directory for this install session. */
+async function makeTempDir() {
+    const base = path_1.default.join(os_1.default.tmpdir(), "kaven-install-");
+    return fs_extra_1.default.mkdtemp(base);
+}
+/** Format bytes into a human-readable string like "245 KB". */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function marketplaceInstall(slug, options = {}) {
     const telemetry = TelemetryBuffer_1.TelemetryBuffer.getInstance();
     const startTime = Date.now();
-    telemetry.capture("cli.marketplace.install.start", { moduleId });
+    telemetry.capture("cli.marketplace.install.start", { slug });
     const authService = new AuthService_1.AuthService();
-    const client = new MarketplaceClient_1.MarketplaceClient();
-    // 1. Verificar Autenticação
-    if (!(await authService.isAuthenticated())) {
-        console.log(chalk_1.default.red("\n❌ Erro: Autenticação necessária."));
-        console.log(chalk_1.default.yellow("O Marketplace da Kaven exige que você esteja logado para instalar módulos."));
-        console.log(chalk_1.default.gray("\nExecute: kaven auth login\n"));
+    const client = new MarketplaceClient_1.MarketplaceClient(authService);
+    const projectRoot = process.cwd();
+    // 1. Verify authentication — required for downloads
+    let accessToken;
+    try {
+        accessToken = await authService.getValidToken();
+    }
+    catch {
+        console.error(chalk_1.default.red("Authentication required. Run: kaven auth login"));
+        telemetry.capture("cli.marketplace.install.error", { slug, error: "not_authenticated" }, Date.now() - startTime);
+        await telemetry.flush();
         process.exit(1);
+        return; // Unreachable but satisfies TS control flow
     }
-    const spinner = (0, ora_1.default)(`Preparando instalação de '${moduleId}'...`).start();
+    void accessToken; // used implicitly via authService in client
+    const spinner = (0, ora_1.default)(`Preparing installation of '${slug}'...`).start();
+    let tempDir = null;
     try {
-        // 2. Buscar Manifest Remoto
-        spinner.text = `Buscando manifest de '${moduleId}' no Marketplace...`;
-        const manifest = await client.getModuleManifest(moduleId);
-        if (!manifest) {
-            spinner.fail(chalk_1.default.red(`Módulo '${moduleId}' não encontrado no Marketplace.`));
+        // 2. Get module metadata
+        spinner.text = `Fetching module '${slug}' from Marketplace...`;
+        let moduleData;
+        try {
+            moduleData = await client.getModule(slug);
+        }
+        catch (error) {
+            if (error instanceof errors_1.NotFoundError) {
+                spinner.fail(chalk_1.default.red(`Module '${slug}' not found in Marketplace.`));
+                process.exit(1);
+                return;
+            }
+            throw error;
+        }
+        const latestVersion = moduleData.latestVersion
+            ?? moduleData.releases?.[0]?.version;
+        const installVersion = options.version ?? latestVersion;
+        if (!installVersion) {
+            spinner.fail(chalk_1.default.red(`No published version found for '${slug}'.`));
             process.exit(1);
+            return;
+        }
+        // 3. Check for conflict before downloading
+        const markerService = new MarkerService_1.MarkerService();
+        const installer = new ModuleInstaller_1.ModuleInstaller(projectRoot, markerService);
+        // Check if already installed by looking at marker files
+        const isInstalled = await installer.isModuleInstalled(slug);
+        if (isInstalled && !options.force) {
+            spinner.stop();
+            console.log(chalk_1.default.yellow(`Module '${slug}' is already installed. Use --force to overwrite.`));
+            telemetry.capture("cli.marketplace.install.skipped", { slug, reason: "already_installed" }, Date.now() - startTime);
+            await telemetry.flush();
+            return;
+        }
+        // 4. Create download token
+        spinner.text = `Creating download token for '${slug}@${installVersion}'...`;
+        const downloadToken = await client.createDownloadToken(slug, installVersion);
+        // 5. Download the tarball to a temp directory
+        tempDir = await makeTempDir();
+        const tarPath = path_1.default.join(tempDir, "module.tar.gz");
+        const extractDir = path_1.default.join(tempDir, "extracted");
+        await fs_extra_1.default.ensureDir(extractDir);
+        // Fetch with size reporting
+        spinner.text = `Downloading ${slug} v${installVersion}...`;
+        const absoluteUrl = await client.resolveUrl(downloadToken.downloadUrl);
+        const response = await fetch(absoluteUrl);
+        if (!response.ok) {
+            throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+        }
+        const contentLength = response.headers.get("content-length");
+        const sizeStr = contentLength
+            ? ` (${formatBytes(parseInt(contentLength, 10))})`
+            : "";
+        spinner.text = `Downloading ${slug} v${installVersion}${sizeStr}...`;
+        if (!response.body) {
+            throw new Error("No response body received for download");
+        }
+        // Stream download to file
+        const fileStream = fs_extra_1.default.createWriteStream(tarPath);
+        const reader = response.body.getReader();
+        await new Promise((resolve, reject) => {
+            const pump = async () => {
+                try {
+                    let reading = true;
+                    while (reading) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            fileStream.end();
+                            reading = false;
+                        }
+                        else {
+                            if (!fileStream.write(value)) {
+                                await new Promise((r) => fileStream.once("drain", r));
+                            }
+                        }
+                    }
+                    fileStream.once("finish", resolve);
+                    fileStream.once("error", reject);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            };
+            pump();
+        });
+        // 6. Verify Ed25519 signature and SHA-256 checksum
+        const stat = await fs_extra_1.default.stat(tarPath);
+        if (stat.size === 0) {
+            throw new Error("Downloaded file is empty");
         }
-        spinner.succeed(chalk_1.default.green(`Módulo '${moduleId}' encontrado.`));
-        // 3. Salvar manifest temporário para usar o moduleAdd existente
-        // Em uma versão futura, o moduleAdd poderia aceitar um objeto de manifest diretamente
-        const tempDir = path_1.default.join(os_1.default.tmpdir(), "kaven-mkt-install");
-        await fs_extra_1.default.ensureDir(tempDir);
-        const tempManifestPath = path_1.default.join(tempDir, `${moduleId}-manifest.json`);
-        await fs_extra_1.default.writeJson(tempManifestPath, manifest);
-        // 4. Executar instalação (reutilizando lógica transacional do moduleAdd)
-        await (0, add_1.moduleAdd)(tempManifestPath);
-        // 5. Cleanup
-        await fs_extra_1.default.remove(tempDir);
-        telemetry.capture("cli.marketplace.install.success", { moduleId }, Date.now() - startTime);
+        if (!options.skipVerify) {
+            spinner.text = `Verifying signature for ${slug} v${installVersion}...`;
+            const releaseInfo = await client.getReleaseInfo(slug, installVersion);
+            if (releaseInfo.checksum &&
+                releaseInfo.signature &&
+                releaseInfo.publicKey) {
+                await (0, SignatureVerifier_1.verifyDownload)({
+                    filePath: tarPath,
+                    expectedChecksum: releaseInfo.checksum,
+                    signature: releaseInfo.signature,
+                    publicKeyBase64: releaseInfo.publicKey,
+                });
+                spinner.text = `Signature verified for ${slug} v${installVersion}`;
+            }
+            else {
+                spinner.text = `No signature data for ${slug} v${installVersion} — skipping verification`;
+            }
+        }
+        // 7. Extract tarball
+        spinner.text = `Extracting ${slug} v${installVersion}...`;
+        await tar.x({ file: tarPath, cwd: extractDir });
+        // 8. Read module.json manifest from extracted dir
+        const manifestPath = path_1.default.join(extractDir, "module.json");
+        const manifestExists = await fs_extra_1.default.pathExists(manifestPath);
+        if (!manifestExists) {
+            throw new Error(`module.json not found in extracted archive for '${slug}'`);
+        }
+        const manifest = await fs_extra_1.default.readJson(manifestPath);
+        // 9. Delegate to ModuleInstaller
+        spinner.text = `Installing ${slug} v${installVersion}...`;
+        await installer.install(manifest);
+        spinner.succeed(chalk_1.default.green(`Module '${slug}@${installVersion}' installed successfully.`));
+        console.log(chalk_1.default.gray(`Use 'kaven module doctor' to verify the installation.`));
+        telemetry.capture("cli.marketplace.install.success", { slug, version: installVersion }, Date.now() - startTime);
         await telemetry.flush();
     }
     catch (error) {
-        telemetry.capture("cli.marketplace.install.error", { moduleId, error: error.message }, Date.now() - startTime);
+        spinner.stop();
+        if (error instanceof errors_1.SignatureVerificationError) {
+            console.error(chalk_1.default.red(`Signature verification failed for '${slug}': ${error.message}`));
+            console.error(chalk_1.default.yellow("Use --skip-verify to bypass (not recommended)."));
+            telemetry.capture("cli.marketplace.install.error", { slug, error: "signature_verification_failed" }, Date.now() - startTime);
+            await telemetry.flush();
+            process.exit(1);
+            return;
+        }
+        if (error instanceof errors_1.LicenseRequiredError) {
+            console.error(chalk_1.default.red(`License required: '${slug}' requires a '${error.requiredTier}' license.`));
+            console.error(chalk_1.default.yellow(`Run: kaven upgrade ${error.requiredTier}`));
+            telemetry.capture("cli.marketplace.install.error", { slug, error: "license_required", tier: error.requiredTier }, Date.now() - startTime);
+            await telemetry.flush();
+            process.exit(1);
+            return;
+        }
+        if (error instanceof errors_1.AuthenticationError ||
+            (error instanceof Error &&
+                error.message.includes("Not authenticated"))) {
+            console.error(chalk_1.default.red("Authentication required. Run: kaven auth login"));
+            telemetry.capture("cli.marketplace.install.error", { slug, error: "auth_error" }, Date.now() - startTime);
+            await telemetry.flush();
+            process.exit(1);
+            return;
+        }
+        if (error instanceof errors_1.NetworkError) {
+            console.error(chalk_1.default.red("Could not reach marketplace. Check your connection."));
+            telemetry.capture("cli.marketplace.install.error", { slug, error: "network_error" }, Date.now() - startTime);
+            await telemetry.flush();
+            process.exit(1);
+            return;
+        }
+        telemetry.capture("cli.marketplace.install.error", { slug, error: error.message }, Date.now() - startTime);
         await telemetry.flush();
-        spinner.fail(chalk_1.default.red(`Falha na instalação do módulo '${moduleId}'.`));
+        spinner.fail(chalk_1.default.red(`Failed to install module '${slug}'.`));
         console.error(error);
         process.exit(1);
     }
+    finally {
+        // 10. Always cleanup temp dir
+        if (tempDir) {
+            await fs_extra_1.default.remove(tempDir).catch(() => {
+                // Ignore cleanup errors
+            });
+        }
+    }
 }

package/dist/commands/marketplace/list.js

@@ -6,38 +6,116 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.marketplaceList = marketplaceList;
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
 const MarketplaceClient_1 = require("../../infrastructure/MarketplaceClient");
+const AuthService_1 = require("../../core/AuthService");
+const errors_1 = require("../../infrastructure/errors");
 const TelemetryBuffer_1 = require("../../infrastructure/TelemetryBuffer");
-async function marketplaceList() {
+function colorTier(tier) {
+    switch (tier.toLowerCase()) {
+        case "starter":
+            return chalk_1.default.green(tier.toLowerCase());
+        case "complete":
+            return chalk_1.default.yellow(tier.toLowerCase());
+        case "pro":
+            return chalk_1.default.magenta(tier.toLowerCase());
+        case "enterprise":
+            return chalk_1.default.blue(tier.toLowerCase());
+        default:
+            return tier;
+    }
+}
+async function marketplaceList(options = {}) {
     const telemetry = TelemetryBuffer_1.TelemetryBuffer.getInstance();
     const startTime = Date.now();
     telemetry.capture("cli.marketplace.list.start");
-    const client = new MarketplaceClient_1.MarketplaceClient();
-    const spinner = (0, ora_1.default)("Buscando módulos no Marketplace...").start();
+    const authService = new AuthService_1.AuthService();
+    const client = new MarketplaceClient_1.MarketplaceClient(authService);
+    const page = options.page ?? 1;
+    const pageSize = Math.min(options.limit ?? 20, 100);
+    const sort = options.sort ?? "newest";
+    // Check auth — warn but don't block
+    const isAuth = await authService.isAuthenticated();
+    if (!isAuth) {
+        console.log(chalk_1.default.yellow("Warning: Not authenticated. Only public modules will be shown. Run: kaven auth login"));
+    }
+    const spinner = (0, ora_1.default)("Fetching modules from Marketplace...").start();
     try {
-        const modules = await client.listModules();
+        const result = await client.listModules({
+            category: options.category,
+            page,
+            pageSize,
+            q: sort === "newest" ? undefined : undefined,
+        });
         spinner.stop();
+        const modules = result.data;
+        const meta = result.meta;
+        const total = result.total ?? meta?.total ?? modules.length;
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            telemetry.capture("cli.marketplace.list.success", { count: modules.length, json: true }, Date.now() - startTime);
+            await telemetry.flush();
+            return;
+        }
         if (modules.length === 0) {
-            console.log(chalk_1.default.yellow("Nenhum módulo encontrado no Marketplace no momento."));
+            console.log(chalk_1.default.yellow("No modules found matching your criteria."));
+            telemetry.capture("cli.marketplace.list.success", { count: 0 }, Date.now() - startTime);
+            await telemetry.flush();
             return;
         }
-        console.log(chalk_1.default.blue.bold("\n📦 Módulos Disponíveis no Marketplace:\n"));
-        // Header (manual alignment)
-        console.log(chalk_1.default.gray(`${"ID".padEnd(20)} ${"NOME".padEnd(20)} ${"VERSÃO".padEnd(10)} ${"AUTOR"}`));
-        console.log(chalk_1.default.gray("-".repeat(70)));
-        modules.forEach((mod) => {
-            console.log(`${chalk_1.default.cyan(mod.id.padEnd(20))} ${chalk_1.default.white(mod.name.padEnd(20))} ${chalk_1.default.green(mod.version.padEnd(10))} ${chalk_1.default.gray(mod.author)}`);
-            console.log(chalk_1.default.italic.gray(`   > ${mod.description}\n`));
+        const table = new cli_table3_1.default({
+            head: [
+                chalk_1.default.white.bold("Slug"),
+                chalk_1.default.white.bold("Name"),
+                chalk_1.default.white.bold("Version"),
+                chalk_1.default.white.bold("Tier"),
+                chalk_1.default.white.bold("Installs"),
+            ],
+            style: {
+                head: [],
+                border: ["gray"],
+            },
         });
-        console.log(chalk_1.default.gray(`Total: ${modules.length} módulos encontrados.\n`));
-        console.log(chalk_1.default.gray("Use 'kaven marketplace install <id>' para instalar um módulo."));
-        telemetry.capture("cli.marketplace.list.success", { count: modules.length }, Date.now() - startTime);
+        // Sort modules client-side based on sort option
+        const sorted = [...modules];
+        if (sort === "popular") {
+            sorted.sort((a, b) => b.installCount - a.installCount);
+        }
+        else if (sort === "name") {
+            sorted.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        // newest = default server-side order
+        for (const mod of sorted) {
+            table.push([
+                chalk_1.default.cyan(mod.slug),
+                chalk_1.default.white(mod.name),
+                chalk_1.default.green(mod.latestVersion ?? "—"),
+                colorTier(mod.requiredTier ?? mod.tier ?? ""),
+                chalk_1.default.gray(String(mod.installCount)),
+            ]);
+        }
+        console.log(chalk_1.default.blue.bold("\nAvailable Marketplace Modules:\n"));
+        console.log(table.toString());
+        // Pagination footer
+        const totalPages = Math.ceil(total / pageSize);
+        const startItem = (page - 1) * pageSize + 1;
+        const endItem = Math.min(page * pageSize, total);
+        console.log(chalk_1.default.gray(`\nShowing ${startItem}-${endItem} of ${total} modules (page ${page}/${totalPages})`));
+        console.log(chalk_1.default.gray("Use 'kaven marketplace install <slug>' to install a module."));
+        telemetry.capture("cli.marketplace.list.success", { count: modules.length, total }, Date.now() - startTime);
         await telemetry.flush();
     }
     catch (error) {
+        spinner.stop();
+        if (error instanceof errors_1.NetworkError) {
+            console.error(chalk_1.default.red("Could not reach marketplace. Check your connection."));
+            telemetry.capture("cli.marketplace.list.error", { error: "network_error" }, Date.now() - startTime);
+            await telemetry.flush();
+            process.exit(1);
+        }
         telemetry.capture("cli.marketplace.list.error", { error: error.message }, Date.now() - startTime);
         await telemetry.flush();
-        spinner.fail(chalk_1.default.red("Erro ao buscar módulos no Marketplace."));
+        console.error(chalk_1.default.red("Error fetching modules from Marketplace."));
         console.error(error);
         process.exit(1);
     }

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);
 }