@tostudy-ai/mcp-setup 1.0.2 → 1.1.0

package/dist/repair.js

@@ -5,13 +5,13 @@
  * Provides automatic repair functions for common MCP configuration issues.
  * Works in conjunction with diagnose.ts to fix detected problems.
  */
-import { existsSync, mkdirSync, writeFileSync, copyFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-import chalk from 'chalk';
-import { getClaudeConfigPath, readClaudeConfig, writeClaudeConfig, addTostudyMcpServer, } from './config.js';
-import { runDiagnostics } from './diagnose.js';
-const DEFAULT_PLATFORM_URL = 'https://tostudy.com';
-function println(message = '') {
+import { existsSync, mkdirSync, writeFileSync, copyFileSync } from "node:fs";
+import { dirname } from "node:path";
+import chalk from "chalk";
+import { getClaudeConfigPath, readClaudeConfig, writeClaudeConfig, addTostudyMcpServer, extractApiKey, extractMcpUrl, } from "./config.js";
+import { runDiagnostics } from "./diagnose.js";
+const DEFAULT_PLATFORM_URL = "https://tostudy.com";
+function println(message = "") {
     process.stdout.write(`${message}\n`);
 }
 /**
@@ -29,17 +29,17 @@ function repairMissingConfig() {
         const initialConfig = {
             mcpServers: {},
         };
-        writeFileSync(configPath, JSON.stringify(initialConfig, null, 2), 'utf-8');
+        writeFileSync(configPath, JSON.stringify(initialConfig, null, 2), "utf-8");
         return {
-            issueId: 'config-missing',
+            issueId: "config-missing",
             success: true,
-            message: 'Arquivo de configuracao criado com sucesso.',
+            message: "Arquivo de configuracao criado com sucesso.",
             action: `Criado: ${configPath}`,
         };
     }
     catch (error) {
         return {
-            issueId: 'config-missing',
+            issueId: "config-missing",
             success: false,
             message: `Falha ao criar arquivo de configuracao: ${error instanceof Error ? error.message : String(error)}`,
         };
@@ -59,23 +59,23 @@ function repairInvalidJson() {
             const freshConfig = {
                 mcpServers: {},
             };
-            writeFileSync(configPath, JSON.stringify(freshConfig, null, 2), 'utf-8');
+            writeFileSync(configPath, JSON.stringify(freshConfig, null, 2), "utf-8");
             return {
-                issueId: 'config-invalid-json',
+                issueId: "config-invalid-json",
                 success: true,
-                message: 'Arquivo de configuracao recriado. Backup salvo.',
+                message: "Arquivo de configuracao recriado. Backup salvo.",
                 action: `Backup: ${backupPath}`,
             };
         }
         return {
-            issueId: 'config-invalid-json',
+            issueId: "config-invalid-json",
             success: false,
-            message: 'Arquivo de configuracao nao existe.',
+            message: "Arquivo de configuracao nao existe.",
         };
     }
     catch (error) {
         return {
-            issueId: 'config-invalid-json',
+            issueId: "config-invalid-json",
             success: false,
             message: `Falha ao reparar JSON: ${error instanceof Error ? error.message : String(error)}`,
         };
@@ -88,15 +88,15 @@ function repairMcpNotConfigured(apiKey, platformUrl = DEFAULT_PLATFORM_URL) {
     try {
         addTostudyMcpServer(apiKey, platformUrl);
         return {
-            issueId: 'mcp-not-configured',
+            issueId: "mcp-not-configured",
             success: true,
-            message: 'Servidor MCP da Catalyst configurado com sucesso.',
-            action: 'Servidor tostudy adicionado',
+            message: "Servidor MCP da Catalyst configurado com sucesso.",
+            action: "Servidor tostudy adicionado",
         };
     }
     catch (error) {
         return {
-            issueId: 'mcp-not-configured',
+            issueId: "mcp-not-configured",
             success: false,
             message: `Falha ao configurar MCP: ${error instanceof Error ? error.message : String(error)}`,
         };
@@ -110,92 +110,116 @@ function repairApiKeyMissing(apiKey, platformUrl = DEFAULT_PLATFORM_URL) {
         // Re-add the server with the correct API key
         addTostudyMcpServer(apiKey, platformUrl);
         return {
-            issueId: 'api-key-missing',
+            issueId: "api-key-missing",
             success: true,
-            message: 'API key configurada com sucesso.',
-            action: 'Header Authorization adicionado',
+            message: "API key configurada com sucesso.",
+            action: "Header Authorization adicionado",
         };
     }
     catch (error) {
         return {
-            issueId: 'api-key-missing',
+            issueId: "api-key-missing",
             success: false,
             message: `Falha ao configurar API key: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
 }
 /**
- * Fix invalid API key format (missing Bearer prefix)
+ * Fix invalid API key format (supports both SSE and stdio formats)
  */
 function repairApiKeyFormat() {
     const config = readClaudeConfig();
-    const mcpConfig = config.mcpServers?.['tostudy'];
+    const mcpConfig = config.mcpServers?.["tostudy"];
     if (!mcpConfig) {
         return {
-            issueId: 'api-key-invalid-format',
+            issueId: "api-key-invalid-format",
             success: false,
-            message: 'Servidor MCP nao esta configurado.',
+            message: "Servidor MCP nao esta configurado.",
         };
     }
     try {
-        const authHeader = mcpConfig.headers?.['Authorization'] || '';
-        // If it's just the key without Bearer prefix, add it
-        if (authHeader && !authHeader.startsWith('Bearer ')) {
-            if (!mcpConfig.headers) {
-                mcpConfig.headers = {};
+        // SSE format: fix headers
+        if (mcpConfig.headers) {
+            const authHeader = mcpConfig.headers["Authorization"] || "";
+            if (authHeader && !authHeader.startsWith("Bearer ")) {
+                mcpConfig.headers["Authorization"] = `Bearer ${authHeader}`;
+                writeClaudeConfig(config);
+                return {
+                    issueId: "api-key-invalid-format",
+                    success: true,
+                    message: "Formato de API key corrigido.",
+                    action: 'Prefixo "Bearer " adicionado',
+                };
+            }
+        }
+        // Stdio format: fix args
+        if (mcpConfig.args) {
+            for (let i = 0; i < mcpConfig.args.length; i++) {
+                if (mcpConfig.args[i] === "--header" &&
+                    mcpConfig.args[i + 1]?.startsWith("Authorization:")) {
+                    const value = mcpConfig.args[i + 1].replace("Authorization:", "");
+                    if (value && !value.startsWith("Bearer ")) {
+                        mcpConfig.args[i + 1] = `Authorization:Bearer ${value}`;
+                        writeClaudeConfig(config);
+                        return {
+                            issueId: "api-key-invalid-format",
+                            success: true,
+                            message: "Formato de API key corrigido.",
+                            action: 'Prefixo "Bearer " adicionado',
+                        };
+                    }
+                }
             }
-            mcpConfig.headers['Authorization'] = `Bearer ${authHeader}`;
-            writeClaudeConfig(config);
-            return {
-                issueId: 'api-key-invalid-format',
-                success: true,
-                message: 'Formato de API key corrigido.',
-                action: 'Prefixo "Bearer " adicionado',
-            };
         }
         return {
-            issueId: 'api-key-invalid-format',
+            issueId: "api-key-invalid-format",
             success: false,
-            message: 'API key nao encontrada para corrigir.',
+            message: "API key nao encontrada para corrigir.",
         };
     }
     catch (error) {
         return {
-            issueId: 'api-key-invalid-format',
+            issueId: "api-key-invalid-format",
             success: false,
             message: `Falha ao corrigir formato: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
 }
 /**
- * Fix missing or invalid server URL
+ * Fix missing or invalid server URL by re-adding with correct config
  */
 function repairServerUrl(platformUrl = DEFAULT_PLATFORM_URL) {
     const config = readClaudeConfig();
-    const mcpConfig = config.mcpServers?.['tostudy'];
+    const mcpConfig = config.mcpServers?.["tostudy"];
     if (!mcpConfig) {
         return {
-            issueId: 'server-url-missing',
+            issueId: "server-url-missing",
             success: false,
-            message: 'Servidor MCP nao esta configurado.',
+            message: "Servidor MCP nao esta configurado.",
         };
     }
     try {
-        // Construct the correct MCP SSE URL
-        const mcpServerUrl = platformUrl.replace(':3700', ':3701');
-        mcpConfig.url = `${mcpServerUrl}/mcp/sse`;
-        mcpConfig.type = 'sse';
-        writeClaudeConfig(config);
+        // Extract existing API key to preserve it
+        const apiKey = extractApiKey(mcpConfig);
+        if (!apiKey) {
+            return {
+                issueId: "server-url-missing",
+                success: false,
+                message: "API key nao encontrada para reconstruir configuracao.",
+            };
+        }
+        // Re-add with correct URL using stdio format
+        addTostudyMcpServer(apiKey, platformUrl);
         return {
-            issueId: 'server-url-missing',
+            issueId: "server-url-missing",
             success: true,
-            message: 'URL do servidor configurada.',
-            action: `URL: ${mcpConfig.url}`,
+            message: "URL do servidor configurada.",
+            action: `URL: ${platformUrl}/mcp`,
         };
     }
     catch (error) {
         return {
-            issueId: 'server-url-missing',
+            issueId: "server-url-missing",
             success: false,
             message: `Falha ao configurar URL: ${error instanceof Error ? error.message : String(error)}`,
         };
@@ -206,76 +230,96 @@ function repairServerUrl(platformUrl = DEFAULT_PLATFORM_URL) {
  */
 function repairServerUrlProtocol(platformUrl = DEFAULT_PLATFORM_URL) {
     const config = readClaudeConfig();
-    const mcpConfig = config.mcpServers?.['tostudy'];
-    if (!mcpConfig?.url) {
+    const mcpConfig = config.mcpServers?.["tostudy"];
+    if (!mcpConfig) {
         return {
-            issueId: 'server-url-invalid-protocol',
+            issueId: "server-url-invalid-protocol",
             success: false,
-            message: 'URL do servidor nao configurada.',
+            message: "Servidor MCP nao esta configurado.",
+        };
+    }
+    const url = extractMcpUrl(mcpConfig);
+    if (!url) {
+        return {
+            issueId: "server-url-invalid-protocol",
+            success: false,
+            message: "URL do servidor nao configurada.",
         };
     }
     try {
-        // Parse the existing URL and fix the protocol
-        const existingUrl = mcpConfig.url;
-        // Replace invalid protocol with https
-        const fixedUrl = existingUrl.replace(/^[a-z]+:/, 'https:');
-        mcpConfig.url = fixedUrl;
-        writeClaudeConfig(config);
+        // Fix the protocol to https and re-add
+        const fixedUrl = url.replace(/^[a-z]+:/, "https:");
+        // Extract base platform URL from the fixed URL
+        const basePlatformUrl = fixedUrl.replace(/\/mcp(\/sse)?$/, "");
+        const apiKey = extractApiKey(mcpConfig);
+        if (!apiKey) {
+            return {
+                issueId: "server-url-invalid-protocol",
+                success: false,
+                message: "API key nao encontrada para reconstruir configuracao.",
+            };
+        }
+        addTostudyMcpServer(apiKey, basePlatformUrl);
         return {
-            issueId: 'server-url-invalid-protocol',
+            issueId: "server-url-invalid-protocol",
             success: true,
-            message: 'Protocolo da URL corrigido para HTTPS.',
-            action: `URL: ${fixedUrl}`,
+            message: "Protocolo da URL corrigido para HTTPS.",
+            action: `URL: ${basePlatformUrl}/mcp`,
         };
     }
     catch (error) {
         return {
-            issueId: 'server-url-invalid-protocol',
+            issueId: "server-url-invalid-protocol",
             success: false,
             message: `Falha ao corrigir protocolo: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
 }
 /**
- * Fix URL missing /mcp/sse path
+ * Fix URL missing /mcp path
  */
 function repairServerUrlPath() {
     const config = readClaudeConfig();
-    const mcpConfig = config.mcpServers?.['tostudy'];
-    if (!mcpConfig?.url) {
+    const mcpConfig = config.mcpServers?.["tostudy"];
+    if (!mcpConfig) {
+        return {
+            issueId: "server-url-missing-sse-path",
+            success: false,
+            message: "Servidor MCP nao esta configurado.",
+        };
+    }
+    const url = extractMcpUrl(mcpConfig);
+    if (!url) {
         return {
-            issueId: 'server-url-missing-sse-path',
+            issueId: "server-url-missing-sse-path",
             success: false,
-            message: 'URL do servidor nao configurada.',
+            message: "URL do servidor nao configurada.",
         };
     }
     try {
-        let url = mcpConfig.url;
-        // Parse URL and fix path
         const parsedUrl = new URL(url);
-        // Remove trailing slash and add /mcp/sse
-        parsedUrl.pathname = parsedUrl.pathname.replace(/\/$/, '');
-        if (!parsedUrl.pathname.endsWith('/mcp/sse')) {
-            // If it ends with /mcp, just add /sse
-            if (parsedUrl.pathname.endsWith('/mcp')) {
-                parsedUrl.pathname += '/sse';
-            }
-            else {
-                parsedUrl.pathname += '/mcp/sse';
-            }
+        // Extract base URL (strip /mcp or /mcp/sse if present, then re-add /mcp)
+        parsedUrl.pathname = parsedUrl.pathname.replace(/\/(mcp(\/sse)?)?$/, "");
+        const basePlatformUrl = parsedUrl.toString().replace(/\/$/, "");
+        const apiKey = extractApiKey(mcpConfig);
+        if (!apiKey) {
+            return {
+                issueId: "server-url-missing-sse-path",
+                success: false,
+                message: "API key nao encontrada para reconstruir configuracao.",
+            };
         }
-        mcpConfig.url = parsedUrl.toString();
-        writeClaudeConfig(config);
+        addTostudyMcpServer(apiKey, basePlatformUrl);
         return {
-            issueId: 'server-url-missing-sse-path',
+            issueId: "server-url-missing-sse-path",
             success: true,
-            message: 'Path /mcp/sse adicionado a URL.',
-            action: `URL: ${mcpConfig.url}`,
+            message: "Path /mcp corrigido na URL.",
+            action: `URL: ${basePlatformUrl}/mcp`,
         };
     }
     catch (error) {
         return {
-            issueId: 'server-url-missing-sse-path',
+            issueId: "server-url-missing-sse-path",
             success: false,
             message: `Falha ao corrigir path: ${error instanceof Error ? error.message : String(error)}`,
         };
@@ -288,25 +332,25 @@ function repairDuplicateServers() {
     const config = readClaudeConfig();
     if (!config.mcpServers) {
         return {
-            issueId: 'duplicate-servers',
+            issueId: "duplicate-servers",
             success: false,
-            message: 'Nenhum servidor MCP configurado.',
+            message: "Nenhum servidor MCP configurado.",
         };
     }
     try {
         const servers = Object.entries(config.mcpServers);
-        const anaServers = servers.filter(([key, server]) => key.toLowerCase().includes('ana') ||
-            key.toLowerCase().includes('catalyst') ||
-            (server.url && server.url.includes('tostudy.com')));
+        const anaServers = servers.filter(([key, server]) => key.toLowerCase().includes("ana") ||
+            key.toLowerCase().includes("catalyst") ||
+            (server.url && server.url.includes("tostudy.com")));
         if (anaServers.length <= 1) {
             return {
-                issueId: 'duplicate-servers',
+                issueId: "duplicate-servers",
                 success: true,
-                message: 'Nenhuma duplicata encontrada.',
+                message: "Nenhuma duplicata encontrada.",
             };
         }
         // Keep the tostudy entry if it exists, otherwise keep the first one
-        const primaryKey = anaServers.find(([key]) => key === 'tostudy')?.[0] || anaServers[0][0];
+        const primaryKey = anaServers.find(([key]) => key === "tostudy")?.[0] || anaServers[0][0];
         const removedKeys = [];
         for (const [key] of anaServers) {
             if (key !== primaryKey) {
@@ -316,78 +360,78 @@ function repairDuplicateServers() {
         }
         writeClaudeConfig(config);
         return {
-            issueId: 'duplicate-servers',
+            issueId: "duplicate-servers",
             success: true,
             message: `${removedKeys.length} servidor(es) duplicado(s) removido(s).`,
-            action: `Removidos: ${removedKeys.join(', ')}`,
+            action: `Removidos: ${removedKeys.join(", ")}`,
         };
     }
     catch (error) {
         return {
-            issueId: 'duplicate-servers',
+            issueId: "duplicate-servers",
             success: false,
             message: `Falha ao remover duplicatas: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
 }
 const REPAIR_FUNCTIONS = {
-    'config-missing': () => repairMissingConfig(),
-    'config-invalid-json': () => repairInvalidJson(),
-    'mcp-not-configured': (apiKey, platformUrl) => {
+    "config-missing": () => repairMissingConfig(),
+    "config-invalid-json": () => repairInvalidJson(),
+    "mcp-not-configured": (apiKey, platformUrl) => {
         if (!apiKey) {
             return {
-                issueId: 'mcp-not-configured',
+                issueId: "mcp-not-configured",
                 success: false,
-                message: 'API key necessaria para configurar o MCP.',
+                message: "API key necessaria para configurar o MCP.",
             };
         }
         return repairMcpNotConfigured(apiKey, platformUrl);
     },
-    'api-key-missing': (apiKey, platformUrl) => {
+    "api-key-missing": (apiKey, platformUrl) => {
         if (!apiKey) {
             return {
-                issueId: 'api-key-missing',
+                issueId: "api-key-missing",
                 success: false,
-                message: 'Nova API key necessaria.',
+                message: "Nova API key necessaria.",
             };
         }
         return repairApiKeyMissing(apiKey, platformUrl);
     },
-    'api-key-invalid-format': () => repairApiKeyFormat(),
-    'api-key-too-short': (apiKey, platformUrl) => {
+    "api-key-invalid-format": () => repairApiKeyFormat(),
+    "api-key-too-short": (apiKey, platformUrl) => {
         if (!apiKey) {
             return {
-                issueId: 'api-key-too-short',
+                issueId: "api-key-too-short",
                 success: false,
-                message: 'Nova API key necessaria.',
+                message: "Nova API key necessaria.",
             };
         }
         return repairApiKeyMissing(apiKey, platformUrl);
     },
-    'server-url-missing': (_, platformUrl) => repairServerUrl(platformUrl),
-    'server-url-invalid': (_, platformUrl) => repairServerUrl(platformUrl),
-    'server-url-invalid-protocol': () => repairServerUrlProtocol(),
-    'server-url-missing-sse-path': () => repairServerUrlPath(),
-    'auth-failed': (apiKey, platformUrl) => {
+    "server-url-missing": (_, platformUrl) => repairServerUrl(platformUrl),
+    "server-url-invalid": (_, platformUrl) => repairServerUrl(platformUrl),
+    "server-url-invalid-protocol": () => repairServerUrlProtocol(),
+    "server-url-missing-sse-path": () => repairServerUrlPath(),
+    "auth-failed": (apiKey, platformUrl) => {
         if (!apiKey) {
             return {
-                issueId: 'auth-failed',
+                issueId: "auth-failed",
                 success: false,
-                message: 'Nova API key necessaria. Gere em /student/settings/mcp.',
+                message: "Nova API key necessaria. Gere em /student/settings/mcp.",
             };
         }
         return repairMcpNotConfigured(apiKey, platformUrl);
     },
-    'duplicate-servers': () => repairDuplicateServers(),
+    "duplicate-servers": () => repairDuplicateServers(),
 };
 /**
  * Issues that require user input (API key)
  */
 const ISSUES_REQUIRING_API_KEY = [
-    'mcp-not-configured',
-    'api-key-missing',
-    'api-key-too-short',
-    'auth-failed',
+    "mcp-not-configured",
+    "api-key-missing",
+    "api-key-too-short",
+    "auth-failed",
 ];
 /**
  * Check if an issue requires user input to repair
@@ -426,7 +470,7 @@ export function repairAllIssues(report, apiKey, platformUrl = DEFAULT_PLATFORM_U
             results.push({
                 issueId: issue.id,
                 success: false,
-                message: 'Requer API key para reparar.',
+                message: "Requer API key para reparar.",
             });
             failed++;
             continue;
@@ -462,63 +506,63 @@ export async function diagnoseAndRepair(apiKey, platformUrl = DEFAULT_PLATFORM_U
  */
 export function printRepairReport(report) {
     println();
-    println(chalk.cyan('  ╔═══════════════════════════════════════╗'));
-    println(chalk.cyan('  ║') + chalk.white.bold('   Catalyst MCP Auto-Repair        ') + chalk.cyan('║'));
-    println(chalk.cyan('  ╚═══════════════════════════════════════╝'));
+    println(chalk.cyan("  ╔═══════════════════════════════════════╗"));
+    println(chalk.cyan("  ║") + chalk.white.bold("   Catalyst MCP Auto-Repair        ") + chalk.cyan("║"));
+    println(chalk.cyan("  ╚═══════════════════════════════════════╝"));
     println();
     if (report.repairsAttempted === 0) {
-        println(chalk.green.bold('✓ Nenhum reparo necessario!'));
+        println(chalk.green.bold("✓ Nenhum reparo necessario!"));
         println();
-        println(chalk.gray('Nenhum problema corrigivel automaticamente foi encontrado.'));
+        println(chalk.gray("Nenhum problema corrigivel automaticamente foi encontrado."));
         println();
         return;
     }
     // Summary
-    println(chalk.white.bold('Resumo:'));
+    println(chalk.white.bold("Resumo:"));
     println(`  Reparos tentados: ${report.repairsAttempted}`);
-    println(`  ${chalk.green('✓ Sucesso:')} ${report.repairsSucceeded}`);
+    println(`  ${chalk.green("✓ Sucesso:")} ${report.repairsSucceeded}`);
     if (report.repairsFailed > 0) {
-        println(`  ${chalk.red('✗ Falha:')} ${report.repairsFailed}`);
+        println(`  ${chalk.red("✗ Falha:")} ${report.repairsFailed}`);
     }
     println();
     // Results
-    println(chalk.white.bold('Detalhes:'));
+    println(chalk.white.bold("Detalhes:"));
     println();
     for (const result of report.results) {
         if (result.success) {
-            println(`  ${chalk.green('✓')} ${result.message}`);
+            println(`  ${chalk.green("✓")} ${result.message}`);
             if (result.action) {
                 println(chalk.gray(`    ${result.action}`));
             }
         }
         else {
-            println(`  ${chalk.red('✗')} ${result.message}`);
+            println(`  ${chalk.red("✗")} ${result.message}`);
         }
     }
     println();
     // User input required
     if (report.requiresUserInput.length > 0) {
-        println(chalk.yellow('⚠ Alguns reparos requerem interacao:'));
+        println(chalk.yellow("⚠ Alguns reparos requerem interacao:"));
         println();
-        println('  Para reparar problemas de API key, execute:');
-        println(chalk.cyan('    npx @tostudy-ai/mcp-setup repair --api-key <sua-api-key>'));
+        println("  Para reparar problemas de API key, execute:");
+        println(chalk.cyan("    npx @tostudy-ai/mcp-setup repair --api-key <sua-api-key>"));
         println();
-        println('  Para gerar uma nova API key:');
-        println(chalk.cyan('    https://tostudy.com/student/settings/mcp'));
+        println("  Para gerar uma nova API key:");
+        println(chalk.cyan("    https://tostudy.com/student/settings/mcp"));
         println();
     }
     // Final status
     if (report.repairsFailed === 0 && report.requiresUserInput.length === 0) {
-        println(chalk.green.bold('✓ Todos os reparos concluidos com sucesso!'));
-        println(chalk.gray('  Reinicie o Claude Code para aplicar as mudancas.'));
+        println(chalk.green.bold("✓ Todos os reparos concluidos com sucesso!"));
+        println(chalk.gray("  Reinicie o Claude Code para aplicar as mudancas."));
     }
     else if (report.repairsSucceeded > 0) {
-        println(chalk.yellow('⚠ Alguns reparos foram concluidos, mas outros falharam.'));
-        println(chalk.gray('  Execute o diagnostico novamente para verificar o status.'));
+        println(chalk.yellow("⚠ Alguns reparos foram concluidos, mas outros falharam."));
+        println(chalk.gray("  Execute o diagnostico novamente para verificar o status."));
     }
     else {
-        println(chalk.red('✗ Nenhum reparo foi concluido com sucesso.'));
-        println(chalk.gray('  Verifique os erros acima e tente novamente.'));
+        println(chalk.red("✗ Nenhum reparo foi concluido com sucesso."));
+        println(chalk.gray("  Verifique os erros acima e tente novamente."));
     }
     println();
 }
@@ -529,7 +573,7 @@ export function exportRepairReportJson(report) {
     return JSON.stringify(report, null, 2);
 }
 // CLI entry point
-if (process.argv[1]?.endsWith('repair.js')) {
+if (process.argv[1]?.endsWith("repair.js")) {
     (async () => {
         try {
             // Parse command line arguments
@@ -538,25 +582,25 @@ if (process.argv[1]?.endsWith('repair.js')) {
             let jsonOutput = false;
             for (let i = 2; i < process.argv.length; i++) {
                 const arg = process.argv[i];
-                if (arg === '--api-key' && process.argv[i + 1]) {
+                if (arg === "--api-key" && process.argv[i + 1]) {
                     apiKey = process.argv[++i];
                 }
-                else if (arg === '--url' && process.argv[i + 1]) {
+                else if (arg === "--url" && process.argv[i + 1]) {
                     platformUrl = process.argv[++i];
                 }
-                else if (arg === '--json') {
+                else if (arg === "--json") {
                     jsonOutput = true;
                 }
-                else if (arg === '--help' || arg === '-h') {
-                    println('Catalyst MCP Auto-Repair');
+                else if (arg === "--help" || arg === "-h") {
+                    println("Catalyst MCP Auto-Repair");
                     println();
-                    println('Usage: node repair.js [options]');
+                    println("Usage: node repair.js [options]");
                     println();
-                    println('Options:');
-                    println('  --api-key <key>  API key para reparos que necessitam autenticacao');
-                    println('  --url <url>      URL da plataforma (default: https://tostudy.com)');
-                    println('  --json           Saida em formato JSON');
-                    println('  --help, -h       Mostra esta ajuda');
+                    println("Options:");
+                    println("  --api-key <key>  API key para reparos que necessitam autenticacao");
+                    println("  --url <url>      URL da plataforma (default: https://tostudy.com)");
+                    println("  --json           Saida em formato JSON");
+                    println("  --help, -h       Mostra esta ajuda");
                     println();
                     process.exit(0);
                 }
@@ -575,12 +619,13 @@ if (process.argv[1]?.endsWith('repair.js')) {
                 printRepairReport(repair);
             }
             // Exit code based on repair results
-            const hasUnfixedCritical = diagnostic.issues.some((issue) => issue.severity === 'critical' && !repair.results.find((r) => r.issueId === issue.id && r.success));
+            const hasUnfixedCritical = diagnostic.issues.some((issue) => issue.severity === "critical" &&
+                !repair.results.find((r) => r.issueId === issue.id && r.success));
             process.exit(hasUnfixedCritical ? 1 : 0);
         }
         catch (error) {
-            process.stderr.write(chalk.red('Erro ao executar reparo:\n'));
-            process.stderr.write((error instanceof Error ? error.message : String(error)) + '\n');
+            process.stderr.write(chalk.red("Erro ao executar reparo:\n"));
+            process.stderr.write((error instanceof Error ? error.message : String(error)) + "\n");
             process.exit(1);
         }
     })();