@netoalmanca/advpl-sensei 1.1.6 → 1.2.0

package/dist/__tests__/registry-quality-check.js

@@ -2,8 +2,11 @@
  * Registry Quality Check - Ferranha para verificar qualidade do Function Registry
  */
 import { RegistryAnalyzer } from "../registry-analyzer.js";
+import { loadFunctionRegistry } from "../function-registry.js";
 export async function checkRegistryQuality() {
     console.log("\n🔍 Analisando Function Registry...\n");
+    // Garante que o registry está carregado do JSON
+    await loadFunctionRegistry();
     const analysis = RegistryAnalyzer.analyze();
     const report = RegistryAnalyzer.generateReport(analysis);
     console.log(report);

package/dist/commands/migrate.js

@@ -0,0 +1,164 @@
+/**
+ * Command: advpl_migrate
+ * Converte código ADVPL procedural (.prw) para TLPP OO (.tlpp)
+ */
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export class AdvplMigrator {
+    /**
+     * Executa a migração de um arquivo
+     */
+    static async migrate(options) {
+        const { target, output, namespace = "advpl.sensei.migrated", className: optClassName, wrapper = true } = options;
+        try {
+            const content = await fs.readFile(target, "utf-8");
+            const filename = path.basename(target);
+            const className = optClassName || filename.replace(".prw", "").replace(".tlpp", "");
+            const lines = content.split(/\r?\n/);
+            const migratedLines = [];
+            const functionsFound = [];
+            // 1. Headers e Namespace
+            migratedLines.push("#include 'tlpp-core.th'");
+            migratedLines.push("#include 'tlpp-rest.th'");
+            migratedLines.push("");
+            migratedLines.push(`namespace ${namespace}`);
+            migratedLines.push("");
+            migratedLines.push(`/**`);
+            migratedLines.push(` * Classe ${className} - Migrada automaticamente pelo Advpl Sensei`);
+            migratedLines.push(` */`);
+            migratedLines.push(`class ${className}`);
+            const methodDeclarations = [];
+            const methodImplementations = [];
+            let currentMethod = null;
+            let isStatic = false;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const trimmed = line.trim();
+                const upper = trimmed.toUpperCase();
+                // Ignora includes antigos
+                if (upper.startsWith("#INCLUDE")) {
+                    continue;
+                }
+                // Detecta funções
+                const funcMatch = trimmed.match(/^(USER\s+FUNCTION|STATIC\s+FUNCTION|FUNCTION)\s+([A-Za-z0-9_]+)\s*\((.*)\)/i);
+                if (funcMatch) {
+                    const type = funcMatch[1].toUpperCase();
+                    const name = funcMatch[2];
+                    const params = funcMatch[3];
+                    isStatic = type.includes("STATIC");
+                    const access = isStatic ? "private" : "public";
+                    functionsFound.push(name);
+                    currentMethod = name;
+                    // Adiciona declaração na classe
+                    methodDeclarations.push(`  ${access} method ${name}(${this.typeParams(params)})`);
+                    // Inicia implementação do método
+                    methodImplementations.push("");
+                    methodImplementations.push(`/**`);
+                    methodImplementations.push(` * Método ${name}`);
+                    methodImplementations.push(` */`);
+                    methodImplementations.push(`method ${name}(${this.typeParams(params)}) class ${className}`);
+                }
+                else if (currentMethod) {
+                    // Conteúdo do método
+                    if (upper.startsWith("RETURN")) {
+                        methodImplementations.push(this.transformLine(line));
+                        currentMethod = null;
+                    }
+                    else {
+                        methodImplementations.push(this.transformLine(line));
+                    }
+                }
+            }
+            // Monta a classe final
+            migratedLines.push(...methodDeclarations);
+            migratedLines.push("endclass");
+            migratedLines.push("");
+            migratedLines.push(...methodImplementations);
+            const migratedContent = migratedLines.join("\n");
+            const outFilename = output || target.replace(".prw", ".tlpp");
+            let report = `🚀 Migração concluída com sucesso!\n\n`;
+            report += `📦 **Classe:** \`${className}\`\n`;
+            report += `🌐 **Namespace:** \`${namespace}\`\n`;
+            report += `🛠️ **Funções Migradas:** ${functionsFound.length}\n`;
+            functionsFound.forEach(f => report += `  - \`${f}\` -> \`oObj:${f}()\`\n`);
+            return {
+                success: true,
+                content: migratedContent,
+                filename: outFilename,
+                originalFunctions: functionsFound,
+                report
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                content: "",
+                filename: "",
+                originalFunctions: [],
+                report: `Erro na migração: ${e.message}`
+            };
+        }
+    }
+    /**
+     * Tenta tipar parâmetros baseados em notação húngara
+     */
+    static typeParams(params) {
+        if (!params.trim())
+            return "";
+        return params.split(",").map(p => {
+            const param = p.trim();
+            if (param.startsWith("c"))
+                return `${param} as string`;
+            if (param.startsWith("n"))
+                return `${param} as numeric`;
+            if (param.startsWith("l"))
+                return `${param} as logical`;
+            if (param.startsWith("d"))
+                return `${param} as date`;
+            if (param.startsWith("a"))
+                return `${param} as array`;
+            if (param.startsWith("o"))
+                return `${param} as object`;
+            return param;
+        }).join(", ");
+    }
+    /**
+     * Transforma linhas de código (ex: Local -> tipado)
+     */
+    static transformLine(line) {
+        const trimmed = line.trim();
+        const upper = trimmed.toUpperCase();
+        // Transforma Local cVar := "" para Local cVar as string := ""
+        if (upper.startsWith("LOCAL ")) {
+            const rest = line.substring(line.toUpperCase().indexOf("LOCAL ") + 6);
+            const parts = rest.split(",");
+            const typedParts = parts.map(p => {
+                const part = p.trim();
+                const varNameMatch = part.match(/^([a-z][A-Za-z0-9_]*)/);
+                if (varNameMatch) {
+                    const varName = varNameMatch[1];
+                    const type = this.getTlppType(varName);
+                    if (type && !part.includes(" as ")) {
+                        return part.replace(varName, `${varName} as ${type}`);
+                    }
+                }
+                return p;
+            });
+            return line.substring(0, line.toUpperCase().indexOf("LOCAL ") + 6) + typedParts.join(", ");
+        }
+        return line;
+    }
+    static getTlppType(varName) {
+        const prefix = varName[0];
+        switch (prefix) {
+            case 'c': return 'string';
+            case 'n': return 'numeric';
+            case 'l': return 'logical';
+            case 'd': return 'date';
+            case 'a': return 'array';
+            case 'o': return 'object';
+            case 'b': return 'codeblock';
+            default: return null;
+        }
+    }
+}

package/dist/commands/review.js

@@ -0,0 +1,82 @@
+/**
+ * Command: advpl_review
+ * Executa revisão completa de código (Lint + Arquitetura)
+ */
+import { SenseiLinter } from "../linter.js";
+export class AdvplReviewer {
+    /**
+     * Realiza o review de um arquivo
+     */
+    static review(content, filename) {
+        // 1. Lint Básico
+        const lintResult = SenseiLinter.lint(content, filename);
+        // 2. Análise de Arquitetura
+        const archIssues = [];
+        const recommendations = [];
+        const upperContent = content.toUpperCase();
+        // Check para Area Handling
+        if (upperContent.includes("DBSELECTAREA") && !upperContent.includes("GETAREA")) {
+            archIssues.push("Uso de DbSelectArea sem salvamento de área (GetArea/RestArea).");
+            recommendations.push("Sempre utilize GetArea() e RestArea() ao manipular tabelas para evitar efeitos colaterais em outras rotinas.");
+        }
+        // Check para Error Handling
+        if (!upperContent.includes("BEGIN SEQUENCE") && content.length > 500) {
+            archIssues.push("Código extenso sem tratamento de erros (Begin Sequence).");
+            recommendations.push("Implemente blocos Begin Sequence / Recover para tornar o código mais resiliente a falhas de banco ou runtime.");
+        }
+        // Check para MVC (heurística simples)
+        if (upperContent.includes("FWMBROWSE") && !upperContent.includes("MODELDEF")) {
+            archIssues.push("Uso de FWMBrowse sem estrutura MVC clara.");
+            recommendations.push("Considere migrar para o padrão MVC completo (ModelDef, ViewDef, MenuDef) para melhor manutenibilidade.");
+        }
+        // Cálculo de Score
+        const totalIssues = lintResult.issues.length + archIssues.length;
+        let score = 100 - (totalIssues * 5);
+        if (score < 0)
+            score = 0;
+        // Sumário
+        let summary = `📊 Review de \`${filename}\` concluído.\n`;
+        summary += `🎯 **Score:** ${score}/100\n`;
+        summary += `⚠️ **Problemas de Lint:** ${lintResult.issues.length}\n`;
+        summary += `🏛️ **Problemas de Arquitetura:** ${archIssues.length}\n`;
+        return {
+            filename,
+            score,
+            lint: lintResult,
+            architectureIssues: archIssues,
+            recommendations,
+            summary
+        };
+    }
+    /**
+     * Formata o resultado para exibição no MCP
+     */
+    static formatResult(result) {
+        let output = result.summary + "\n";
+        if (result.lint.issues.length > 0) {
+            output += `### 🔍 Problemas de Estilo/Lint\n`;
+            result.lint.issues.forEach(issue => {
+                const icon = issue.severity === "error" ? "🔴" : "🟡";
+                output += `- ${icon} [${issue.code}] Linha ${issue.line}: ${issue.message}\n`;
+            });
+            output += "\n";
+        }
+        if (result.architectureIssues.length > 0) {
+            output += `### 🏛️ Problemas de Arquitetura\n`;
+            result.architectureIssues.forEach(issue => {
+                output += `- ❌ ${issue}\n`;
+            });
+            output += "\n";
+        }
+        if (result.recommendations.length > 0) {
+            output += `### 💡 Recomendações do Sensei\n`;
+            result.recommendations.forEach(rec => {
+                output += `- ${rec}\n`;
+            });
+        }
+        if (result.score >= 90) {
+            output += `\n✅ **Parabéns!** O código segue as melhores práticas do ecossistema Protheus.`;
+        }
+        return output;
+    }
+}